daw Namespace Reference

Provides structs for wrapping function pointers and callable objects to facilitate function overloading and safe invocation. More...

Namespaces
namespace	algorithm
namespace	container
namespace	cxmath
namespace	deprecated
namespace	ensure
namespace	exception
namespace	filesystem
namespace	func
namespace	int_string_sizes
namespace	integers
namespace	literals
namespace	math
namespace	memory
namespace	metro
namespace	min_strings
namespace	mixins
namespace	monadic_ptr
namespace	nparam
namespace	parser
namespace	pipelines
namespace	range
namespace	size_literals
namespace	string
namespace	string_fmt
namespace	sv1
namespace	sv2
namespace	swappable_test
namespace	traits
namespace	traits_is_sv
namespace	tuple
namespace	unique_ptr_del
namespace	utility

Classes
struct	AllocDeleter
struct	always_false
struct	any_of_t
	A predicate type used in the find based routine to return true when the element is one of the specified characters. More...
struct	applier_t
class	arg_iterator_t
struct	Argument
class	Arguments
struct	array
struct	arrow_proxy
struct	back_inserter
class	basic_bit_queue
struct	basic_bounded_string
class	basic_nibble_queue
struct	basic_safe_string
struct	bidirectional_counting_iterator
struct	bind_args_at_fn
class	bind_front
struct	bit_iterator
	An output iterator that calls supplied bit when operator= is called This is like std::back_insert_iterator. More...
struct	bit_queue_source_big_endian
struct	bit_queue_source_little_endian
struct	bit_stream
class	bitset
class	bounded_graph_node_t
struct	bounded_graph_t
struct	bounded_hash_map
struct	bounded_hash_map_item_t
struct	bounded_hash_map_iterator
struct	bounded_hash_set_iterator
struct	bounded_hash_set_t
struct	bounded_vector_t
struct	bounded_vector_t< T, 0 >
struct	carray
class	CFile
struct	char_splitter_t
struct	checked_expected_t
struct	checked_expected_t< void, ExpectedExceptions... >
class	checked_function_t
class	checked_iterator_proxy_t
struct	chunk_iterator
struct	circular_iterator
class	clumpy_sparsy
struct	clumpy_sparsy_iterator
struct	compressed_pair
struct	compressed_pair_elem
struct	compressed_pair_elem< Tp, Idx, true >
struct	const_bounded_hash_map_iterator
struct	const_bounded_hash_set_iterator
class	const_graph_node_t
struct	constant
struct	construct_a_t
	Construct a value. If normal ( ) construction does not work try aggregate. More...
struct	construct_a_t< daw::use_aggregate_construction< T > >
struct	construct_emplace_t
struct	construct_for_overwrite_t
class	container_data
struct	container_deleter
struct	container_traits
struct	container_traits< std::array< T, N > >
struct	container_traits< T[N]>
struct	contiguous_view
struct	contiguous_view< T, ExplicitConv >
class	contract
struct	copiable_unique_ptr
class	countable_resource_t
class	CString
struct	deduced_type
struct	default_deleter
struct	default_deleter< T[]>
struct	default_init_tag
struct	default_pointer_deleter
struct	default_pointer_deleter< T[]>
struct	dependent_type
struct	discard_t
	Tag type for specifying that the searched for term/item is to be removed from view. More...
struct	do_resize_and_overwrite_t
struct	dont_clip_to_bounds_t
struct	empty_t
struct	end_inserter_iterator
class	equal_to_last
struct	escaped_any_of
	Predicate type that stores the previous element and if it was an '\' escape character, it will return false, otherwise returns true if the current character matches one of the needles. Because this is a stateful predicate, it cannot be reused. More...
struct	expander
struct	expected_t
struct	expected_t< void >
struct	extract_from_container_t
struct	extract_from_container_t< std::vector< T, Allocator > >
struct	find_iterator
struct	find_one_element
class	find_one_iterator
struct	fixed_array
struct	fixed_cast
struct	fixed_lookup
	A fixed lookup table. Only indices returned by insert or get_existing are defined. A reference does not exist after a copy/move operation but the indices will remain valid In some testing the average distance to actual value was 0.147 when size is double needed items. More...
struct	fmt_range
struct	fmt_tuple
struct	fnv1a_hash_t
struct	forward_counting_iterator
class	function
class	function< MaxSize, Result(FuncArgs...)>
struct	function_info
struct	function_info< ReturnType(ClassType::*)(Args...) const >
struct	function_info< ReturnType(ClassType::*)(Args...) volatile >
struct	function_info< ReturnType(ClassType::*)(Args...) volatile const >
struct	function_info< ReturnType(ClassType::*)(Args...)>
struct	function_iterator
	An output iterator that calls supplied function when operator= is called This is like std::back_insert_iterator. More...
struct	function_ref
struct	function_ref< Result(Params...)>
struct	function_ref< void(Params...)>
struct	function_table_t
struct	function_traits
struct	function_traits< ReturnType(*)(Args...)>
struct	function_traits< ReturnType(ClassType::*)(Args...) const >
struct	function_traits< ReturnType(ClassType::*)(Args...)>
struct	function_view
struct	function_view< Result(Args...)>
struct	function_view< void(Args...)>
struct	function_view_table_storage
struct	function_view_table_storage< void, Args... >
struct	fwd_pack
struct	fwd_pack<>
struct	generic_hash_t
struct	generic_hash_t< 2 >
struct	generic_hash_t< 4 >
struct	generic_hash_t< 8 >
struct	graph_node_t
struct	graph_t
struct	has_op_minus
struct	has_op_minus< T, U, std::void_t< decltype(std::declval< T >() - std::declval< U >())> >
struct	has_reallocate
struct	has_reallocate< T, std::void_t< typename T::has_realloc > >
class	hash_set_t
struct	hash_table
struct	hash_table_item_iterator
struct	heap_array
struct	heap_value
	Heap Value. Access members via operator-> but copy/move constructors operators utilized the pointed to's members This is used on larger classes that are members of other classes but the space requirements is that of a pointer instead of the full size. More...
struct	indexed_iterator
struct	InputIterator
struct	InputRange
struct	insert_into_container_t
struct	insert_into_container_t< std::vector< T, Allocator > >
struct	inserter_iterator
struct	integer_range
struct	integer_range_iterator
struct	invalid_natural_number
class	invalid_node_exception
struct	iota_iterator
struct	iota_range
struct	is_ascii_alpha_t
struct	is_ascii_alphanum_t
struct	is_ascii_digit_t
struct	is_ascii_printable_t
struct	is_daw_span_t
struct	is_daw_span_t< daw::span< T > >
struct	is_daw_view_t
struct	is_daw_view_t< daw::view< T > >
struct	is_iterator
struct	is_iterator< T, std::void_t< decltype(std::add_pointer_t< typename std::iterator_traits< T >::value_type >{ })> >
struct	is_nothrow_convertible
struct	is_system_integral
struct	is_tuple2
struct	iter_view
struct	iterator_pair
class	keep_n
struct	key_value_t
struct	make_signed
struct	make_unsigned
struct	MallocAlloc
struct	md_stdarray
struct	MMapAlloc
class	move_only
class	move_only< void >
struct	move_only_base
class	mutable_capture
struct	natural_t
struct	never_null_t
class	node_id_t
struct	nodiscard_t
	Tag type for specifying that the searched for term/item is not to be removed from view. More...
struct	none_of_t
	A predicate type used in the find based routine to return true when the element is none of the specified characters. More...
struct	nonesuch
class	not_null
struct	not_null_value_type
struct	numeric_limits
struct	observer_ptr
class	on_exit_success
struct	optional
struct	optional< T, std::enable_if_t< not std::is_reference_v< T > > >
struct	optional< T, std::enable_if_t< std::is_lvalue_reference_v< T > > >
struct	optional_poly
struct	ordered_map
struct	overload
struct	pack_element
struct	pack_element< Idx, Pack< Ts... > >
struct	pack_list
struct	pack_type
struct	perfect_hash_table
struct	piecewise_factory_late_t
struct	piecewise_factory_t
struct	pointer_iterator
class	poly_value
struct	poly_var
class	poly_vector_t
struct	prop_const_ptr
struct	RandomFloat
struct	RandomInteger
struct	RandomIterator
struct	rc_ptr
struct	rc_ptr< T[], Deleter >
struct	read_only
struct	Reference
struct	remove_array_ref
struct	remove_array_ref< T(&)[N]>
struct	repeat_n_char_iterator
struct	reverse_iterator
struct	ring_adaptor
struct	rvalue_to_value
struct	rvalue_to_value< T & >
struct	rvalue_to_value< T && >
struct	sbo_storage
class	ScopeGuard
struct	set_node_t
struct	simple_array
struct	simple_array< T, 0 >
struct	sized_for_overwrite_t
struct	span
struct	span< T, std::enable_if_t< not std::is_const_v< T > > >
struct	span< T, std::enable_if_t< std::is_const_v< T > > >
struct	split_buffer
struct	split_it
struct	split_it< Iterator, Splitter, std::enable_if_t< not std::is_same_v< char, typename std::iterator_traits< Iterator >::value_type > > >
struct	split_it< Iterator, Splitter, std::enable_if_t< std::is_same_v< char, typename std::iterator_traits< Iterator >::value_type > > >
struct	splitter_range_t
class	static_bitset
struct	static_hash_t
struct	static_random
class	string_split_iterator
struct	string_split_range
struct	tag_t
struct	take_ownership_t
struct	take_t
struct	template_param
struct	template_params
struct	template_vals_t
struct	terminate_on_read_file_error_t
struct	to_lower_ascii_t
struct	to_upper_ascii_t
class	topological_sorted_iterator
class	tuple
struct	tuple2
struct	tuple2<>
struct	tuple2_element
struct	tuple2_element< Idx, tuple2< Ts... > >
struct	tuple2_size
struct	tuple2_size< tuple2< Ts... > >
struct	tuple_element
struct	tuple_element< Idx, fwd_pack< Ts... > >
struct	tuple_size
struct	tuple_size< daw::fwd_pack< Ts... > >
struct	type_if_else
struct	type_if_else< true, IfTrue, IfFalse >
struct	undefined_t
struct	uninitialized_storage
class	union_pair_t
struct	unique_array_t
struct	unique_ptr
struct	unique_ptr< T[], Deleter >
class	unique_resource
struct	UnorderedWalk
struct	unsupported_int_size
struct	use_aggregate_construction
struct	use_default
struct	validated
struct	value_init_tag
struct	value_ptr
struct	Vector
struct	vector
struct	view
struct	virtual_base
struct	visit_null_union_pair_exception
class	wrap_iter
struct	zip_container
struct	zip_iterator

Concepts
concept	convertible_to
concept	same_as
concept	same_as_rrcv
concept	cvref_of
concept	not_me
concept	not_cvref_of
concept	not_me_d
concept	not_decay_of
concept	constructible_from
concept	Pointers
concept	Containers
concept	ContiguousContainer
concept	ContiguousContainerOf
concept	StringLike
concept	EnumType
concept	UnsignedStd
concept	SignedStd
concept	IntegralStd
concept	IntegralDaw
concept	FloatingPointStd
concept	FloatingPointDaw
concept	AssociativeContainers
concept	invocable
concept	assignable_from
	Specifies that an expression of the type and value category specified by RHS can be assigned to an lvalue expression whose type is specified by LHS.
concept	move_constructible
	Satisfied if T is a reference type, or if it is an object type where an object of that type can be constructed from an rvalue of that type in both direct- and copy-initialization contexts, with the usual semantics.
concept	swappable
	Specifies that expressions of the type and value category encoded by T and U are swappable with each other.
concept	movable
	Specifies that T is an object type that can be moved (that is, it can be move constructed, move assigned, and lvalues of type T can be swapped).
concept	weakly_incrementable
concept	invocable_result
concept	input_or_output_iterator
concept	indirectly_writable
concept	derived_from
concept	output_iterator
concept	input_iterator
concept	forward_iterator
concept	random_access_iterator
concept	BackInsertableContainer
concept	boolean_testable
	Specifies the requirements for expressions that are convertible to bool and for which the logical operators have the usual behavior (including short-circuiting), even for two different boolean-testable types.
concept	equality_comparable
	Specifies that the comparison operators == and != on T reflects equality: == yields true if and only if the operands are equal.
concept	equality_comparable_with
	Specifies that the comparison operators == and != on (possibly mixed) T and U operands yield results consistent with equality. Comparing mixed operands yields results equivalent to comparing the operands converted to their common type.
concept	Allocators
concept	default_constructible
concept	Integer
concept	FloatingPoint
concept	Arithmetic
concept	constructible_to
concept	Fn
concept	Iterator
concept	IsIteratorTag
concept	OutputIteratorTag
concept	InputIteratorTag
concept	InputIterator
concept	ForwardIteratorTag
concept	ForwardIterator
concept	BidirectionalIteratorTag
concept	BidirectionalIterator
concept	RandomIteratorTag
concept	RandomIterator
concept	Range
concept	InputRange
concept	ForwardRange
concept	BidirectionalRange
concept	RandomRange
concept	has_std_formatter_specialization_v
concept	ResizeAndOverwriteOperationAlloc
concept	ResizeAndOverwriteOperation

Typedefs
template<typename T , typename... Ts>
using	aligned_storage_for_t = typename impl::aligned_storage< std::max({ sizeof(T), sizeof(Ts)... }), std::max({ alignof(T), alignof(Ts)... })>::type
template<std::size_t Size, std::size_t Align = alignof( std::max_align_t )>
using	aligned_storage_t = typename impl::aligned_storage< Size, Align >::type
template<bool... values>
using	all_true = std::bool_constant<(values and ...)>
template<bool... values>
using	any_true = std::bool_constant<(values or ...)>
using	bad_variant_access = std::bad_variant_access
using	bit_queue = basic_bit_queue< uint16_t >
using	bit_queue_source_native_endian = daw::conditional_t< daw::endian::native==daw::endian::little, bit_queue_source_little_endian, bit_queue_source_big_endian >
template<bool B>
using	bool_constant = std::bool_constant< B >
template<typename T , size_t N>
using	bounded_array_t = daw::array< T, N >
using	bounded_string = basic_bounded_string< char, 100 >
template<typename N , typename Invokable , typename TpArgs , typename... Args>
using	can_call_test = std::is_invocable< applier_t< Invokable >, decltype(std::tuple_cat(split_args< 0, N::value >(std::forward_as_tuple(DAW_FWD(std::declval< Args >())...)), std::declval< TpArgs >(), split_args< N::value, sizeof...(Args)>(std::forward_as_tuple(DAW_FWD(std::declval< Args >())...))))>
template<DAW_CXEVAL_FTYPE F>
using	can_constant_evaluate = typename decltype(can_cxeval_impl::can_cxeval< F >())::type
template<typename T , typename... Args>
using	can_potentially_constant_construct = typename conditional_t<(std::is_default_constructible_v< Args > and ...), can_cxeval_impl::can_potentially_constant_construct_impl< T, Args... >, daw::traits::identity< std::false_type > >::type
template<typename T >
using	clumpy_sparsy_const_iterator = clumpy_sparsy_iterator< T const >
template<typename... Its>
using	common_iterator_category_t = daw::remove_cvref_t< decltype(iterator_traits_impl::common_iterator_tag_test_t< std::index_sequence_for< Its... > >::test(std::declval< Its const & >()...))>
template<bool B, typename TrueType , typename FalseType >
using	conditional_t = typename traits_details::select< B >::template type< TrueType, FalseType >
template<typename... Ts>
using	conjunction = conjunction_t< Ts... >
template<typename... Ts>
using	conjunction_t = std::bool_constant< conjunction_v< Ts... > >
template<Range R>
using	const_iterator_end_t = DAW_TYPEOF(std::cend(std::declval< R const & >()))
template<Range R>
using	const_iterator_t = DAW_TYPEOF(std::cbegin(std::declval< R const & >()))
using	cstring = CString< char >
template<typename Default , template< typename... > typename Op, typename... Args>
using	detected_or = is_detect_details::detector< Default, void, Op, Args... >
template<typename Default , template< typename... > typename Op, typename... Args>
using	detected_or_t = typename detected_or< Default, Op, Args... >::type
template<template< typename... > typename Op, typename... Args>
using	detected_t = typename is_detect_details::detector< nonesuch< Op, Args... >, void, Op, Args... >::type
template<typename... Ts>
using	disjunction = disjunction_t< Ts... >
template<typename... Ts>
using	disjunction_t = std::bool_constant< disjunction_v< Ts... > >
using	Empty = empty_t
template<typename T , bool B = true>
using	enable_copy_assignment = traits_details::delete_copy_assignment_if< not std::is_copy_assignable_v< T > and B >
template<typename T , bool B = true>
using	enable_copy_constructor = traits_details::delete_copy_constructor_if< not std::is_copy_constructible_v< T > and B >
template<typename T , bool B = true>
using	enable_default_constructor = traits_details::delete_default_constructor_if< not std::is_default_constructible_v< T > and B >
template<bool B, typename T = std::nullptr_t>
using	enable_if = std::enable_if< B, T >
template<bool B, typename T = std::nullptr_t>
using	enable_if_t = std::enable_if_t< B, T >
template<typename T , bool B = true>
using	enable_move_assignment = traits_details::delete_move_assignment_if< not std::is_move_assignable_v< T > and B >
template<typename T , bool B = true>
using	enable_move_constructor = traits_details::delete_move_constructor_if< not std::is_move_constructible_v< T > and B >
template<typename... Traits>
using	enable_when_all_t = enable_if_t< std::conjunction_v< Traits... > >
template<bool... B>
using	enable_when_t = enable_if_t<(B &&...)>
template<size_t N, typename TpArgs , typename... Args>
using	enough_args_t = std::bool_constant<((sizeof...(Args)+std::tuple_size_v< TpArgs >) >=N)>
template<typename T >
using	fn_t = std::add_pointer_t< T >
using	fnv1a_uint_t = conditional_t< fnv1a_impl::is_64bit_v, std::uint64_t, std::uint32_t >
template<typename T >
using	fp_t = T *
template<typename ResultType , typename... ArgTypes>
using	function_pointer_t = typename utility_details::make_function_pointer_impl< ResultType, ArgTypes... >::type
template<typename F >
using	function_traits_t = typename function_traits< F >::type
using	genhash_uint_t = std::size_t
template<bool Condition, typename IfTrue , typename IfFalse >
using	if_else_t = typename type_if_else< Condition, IfTrue, IfFalse >::type
template<bool Bool_, typename If_ , typename Then_ >
using	if_t = typename std::conditional< Bool_, If_, Then_ >::type
template<auto , typename T >
using	ignore_one_t = T
template<std::size_t N>
using	index_constant = std::integral_constant< std::size_t, N >
template<std::size_t BitSize>
using	intN_t = conditional_t< is_same_size_v< char, BitSize >, char, conditional_t< is_same_size_v< short, BitSize >, short, conditional_t< is_same_size_v< int, BitSize >, int, conditional_t< is_same_size_v< long, BitSize >, long, conditional_t< is_same_size_v< long long, BitSize >, long long, unsupported_int_size< BitSize > > > > > >
template<typename T >
using	is_arithmetic = std::bool_constant< is_arithmetic_v< T > >
template<typename T >
using	is_complete_type = std::bool_constant< is_complete_type_v< T > >
template<template< typename... > typename Op, typename... Args>
using	is_detected = typename is_detect_details::detector< nonesuch< Op, Args... >, void, Op, Args... >::value_t
template<typename To , template< typename... > typename Op, typename... Args>
using	is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >
template<typename Expected , template< typename... > typename Op, typename... Args>
using	is_detected_exact = std::bool_constant< is_detected_exact_v< Expected, Op, Args... > >
template<typename T >
using	is_floating_point = std::bool_constant< is_floating_point_v< T > >
template<typename T >
using	is_integral = std::bool_constant< is_integral_v< T > >
template<typename T >
using	is_number = std::bool_constant< is_number_v< T > >
template<typename T >
using	is_reference_wrapper = std::bool_constant< is_reference_wrapper_v< T > >
template<typename T , typename U >
using	is_same = std::bool_constant< is_same_v< T, U > >
template<typename T , std::size_t BitSize>
using	is_same_size = std::bool_constant<(bit_count_v< T >==BitSize)>
template<typename T , typename U >
using	is_same_t = typename std::bool_constant< is_same_v< T, U > >::type
template<typename T >
using	is_signed = std::bool_constant< is_signed_v< T > >
template<template< typename... > typename Primary, typename T >
using	is_specialization_of = std::bool_constant< is_specialization_of_v< Primary, T > >
template<typename T >
using	is_tuple = std::bool_constant< is_tuple_v< T > >
template<typename T >
using	is_unbounded_array = std::bool_constant< is_unbounded_array_v< T > >
template<typename T >
using	is_unsigned = std::bool_constant< is_unsigned_v< T > >
template<typename It >
using	iter_category_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::iterator_category
template<typename It >
using	iter_const_reference_t = std::common_reference_t< iter_value_t< It > const &&, iter_reference_t< It > >
template<typename It >
using	iter_difference_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::difference_type
template<typename It >
using	iter_pointer_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::pointer
template<typename It >
using	iter_reference_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::reference
template<typename T >
using	iter_reference_type = iter_reference_t< T >
template<typename It >
using	iter_value_t = typename std::iterator_traits< daw::remove_cvref_t< It > >::value_type
template<typename T >
using	iter_value_type = iter_value_t< T >
template<typename T >
using	iterator_category_t = typename std::iterator_traits< T >::iterator_category
template<Range R>
using	iterator_end_t = DAW_TYPEOF(std::end(std::declval< R >()))
template<Range R>
using	iterator_t = DAW_TYPEOF(std::begin(std::declval< R >()))
template<typename T >
using	make_signed_t = typename make_signed< T >::type
template<typename T >
using	make_unsigned_t = typename make_unsigned< T >::type
template<typename T , std::size_t... Extents>
using	md_stdarray_t = typename md_stdarray< T, Extents... >::type
template<typename B >
using	negation = std::bool_constant< not bool(B::value)>
using	nibble_queue = basic_nibble_queue< uint8_t >
template<typename T >
using	non_owning_ptr = T
template<typename Pointer >
using	not_null_pointer_const_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, Pointer, Pointer const & >
template<typename Pointer >
using	not_null_pointer_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, Pointer, Pointer & >
template<typename Pointer >
using	not_null_value_const_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, std::remove_pointer_t< Pointer > const &, not_null_value_type_t< Pointer > const & >
template<typename Pointer >
using	not_null_value_reference_t = std::conditional_t< std::is_pointer_v< Pointer >, std::remove_pointer_t< Pointer > const &, not_null_value_type_t< Pointer > & >
template<typename Pointer >
using	not_null_value_type_t = typename not_null_value_type< Pointer >::type
template<typename T >
using	not_trait = std::bool_constant< not T::value >
using	nothing = empty_t
template<std::size_t Idx, typename Pack >
using	pack_element_t = typename pack_element< Idx, Pack >::type
template<typename T , typename... Ts>
using	pack_index_of = std::integral_constant< std::size_t, pack_index_of_v< T, Ts... > >
template<typename Pack >
using	pack_size = std::integral_constant< std::size_t, pack_size_v< Pack > >
template<size_t N, typename... Ts>
using	pack_type_at = traits::nth_type< N, Ts... >
template<size_t N, typename... Args>
using	pack_type_t = typename pack_type< N, Args... >::type
template<typename Pack , typename T >
using	param_pack_index_of = std::integral_constant< std::size_t, param_pack_index_of_v< Pack, T > >
template<typename ResultType , typename ClassType , typename... ArgTypes>
using	pointer_to_const_member_function_t = typename utility_details::make_pointer_to_const_member_function_impl< ResultType, ClassType, ArgTypes... >::type
template<typename ResultType , typename ClassType , typename... ArgTypes>
using	pointer_to_const_volatile_member_function_t = typename utility_details::make_pointer_to_const_volatile_member_function_impl< ResultType, ClassType, ArgTypes... >::type
template<typename ResultType , typename ClassType , typename... ArgTypes>
using	pointer_to_member_function_t = typename utility_details::make_pointer_to_member_function_impl< ResultType, ClassType, ArgTypes... >::type
template<typename ResultType , typename ClassType , typename... ArgTypes>
using	pointer_to_volatile_member_function_t = typename utility_details::make_pointer_to_volatile_member_function_impl< ResultType, ClassType, ArgTypes... >::type
template<Range R>
using	range_category_t = iter_category_t< iterator_t< R > >
template<Range R>
using	range_const_reference_t = iter_const_reference_t< iterator_t< R > >
template<Range R>
using	range_reference_t = iter_reference_t< iterator_t< R > >
template<Range R>
using	range_value_t = iter_value_t< iterator_t< R > >
template<typename T >
using	remove_array_ref_t = typename remove_array_ref< T >::type
template<typename T >
using	remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T > >
template<typename T >
using	remove_cvrvref_t = std::conditional_t< std::is_rvalue_reference_v< T >, remove_cvref_t< T >, T >
	Make rvalue references remove_cvref_t<T> and alone otherwise.
template<typename T >
using	remove_rvalue_ref_t = daw::conditional_t< std::is_rvalue_reference_v< T >, daw::remove_cvref_t< T >, T >
template<bool B, typename T = std::nullptr_t>
using	required = std::enable_if_t< B, T >
template<typename T >
using	root_type_t = std::remove_cv_t< std::remove_pointer_t< std::decay_t< T > > >
template<typename T >
using	rvalue_to_value_t = typename rvalue_to_value< T >::type
template<typename SanitizeFunction >
using	safe_string = basic_safe_string< SanitizeFunction, char >
template<typename SanitizeFunction >
using	safe_u16string = basic_safe_string< SanitizeFunction, char16_t >
template<typename SanitizeFunction >
using	safe_u32string = basic_safe_string< SanitizeFunction, char32_t >
template<typename SanitizeFunction >
using	safe_wstring = basic_safe_string< SanitizeFunction, wchar_t >
using	String = daw::string::string_details::BasicString< char >
template<std::size_t Index, typename... Cases>
using	switch_t = pack_element_t< Index, pack_list< Cases... > >
template<std::size_t Idx, typename Tuple >
using	tuple2_element_t = typename tuple2_element< Idx, Tuple >::type
template<size_t N, typename... Args>
using	type_n_t = traits::nth_element< N, Args... >
using	u16bounded_string = basic_bounded_string< char16_t, 100 >
using	u32bounded_string = basic_bounded_string< char32_t, 100 >
template<unsigned Bits>
using	UInt = conditional_t<(Bits==8), UInt8, conditional_t<(Bits==16), UInt16, conditional_t<(Bits==32), UInt32, conditional_t<(Bits==64), UInt64, InvalidUIntSize > > > >
template<std::size_t BitSize>
using	uintN_t = conditional_t< is_same_size_v< char, BitSize >, unsigned char, conditional_t< is_same_size_v< short, BitSize >, unsigned short, conditional_t< is_same_size_v< int, BitSize >, unsigned int, conditional_t< is_same_size_v< long, BitSize >, unsigned long, conditional_t< is_same_size_v< unsigned long long, BitSize >, long long, unsupported_int_size< BitSize > > > > > >
template<typename... >
using	void_t = void
using	wbounded_string = basic_bounded_string< wchar_t, 100 >
using	WString = daw::string::string_details::BasicString< wchar_t >

Enumerations
enum class	endian { little = __ORDER_LITTLE_ENDIAN__ , big = __ORDER_BIG_ENDIAN__ , native = __BYTE_ORDER__ }
enum class	keep_n_order { ascending , descending }
enum class	UInt16 : std::uint16_t
enum class	UInt32 : std::uint32_t
enum class	UInt64 : std::uint64_t
enum class	UInt8 : std::uint8_t
enum class	wait_status { found , timeout }

Functions
template<typename Iterator , typename Distance >
constexpr void	advance (Iterator &it, Distance n)
	Advance iterator n steps.
template<typename Distance , typename Iterator >
constexpr void	advance_many (Distance d, Iterator &it)
template<typename Distance , typename Iterator , typename Iterator2 , typename... Iterators>
constexpr void	advance_many (Distance d, Iterator &it, Iterator2 &it2, Iterators &...its)
template<typename... Predicates> requires ( (Fn<Predicates, bool()> or std::convertible_to<Predicates, bool>) and ...)
constexpr bool	any_if (Predicates &&...predicates)
template<typename... Ts>
constexpr auto	any_of_f (Ts &&...needles) noexcept
template<typename Container , typename... Args>
constexpr auto	append (Container &container, Args &&...args)
template<bool use_invoke = true, typename F , typename Tuple >
constexpr decltype(auto)	apply (F &&f, Tuple &&t)
template<typename F , typename... Ts>
constexpr decltype(auto)	apply (F &&f, tuple< Ts... > &&t)
template<typename F , typename... Ts>
constexpr decltype(auto)	apply (F &&f, tuple< Ts... > &t)
template<typename F , typename... Ts>
constexpr decltype(auto)	apply (F &&f, tuple< Ts... > const &&t)
template<typename F , typename... Ts>
constexpr decltype(auto)	apply (F &&f, tuple< Ts... > const &t)
template<typename Func , typename... Ts>
constexpr decltype(auto)	apply (Func &&func, fwd_pack< Ts... > &&p) noexcept(std::is_nothrow_invocable_v< Func, Ts... >)
template<typename Func , typename... Ts>
constexpr decltype(auto)	apply (tuple2< Ts... > &&tp, Func &&fn)
template<typename Func , typename... Ts>
constexpr decltype(auto)	apply (tuple2< Ts... > &tp, Func &&fn)
template<typename Func , typename... Ts>
constexpr decltype(auto)	apply (tuple2< Ts... > const &&tp, Func &&fn)
template<typename Func , typename... Ts>
constexpr decltype(auto)	apply (tuple2< Ts... > const &tp, Func &&fn)
template<typename Arg , typename Callable >
constexpr decltype(auto)	apply_string (Callable &&callable, daw::string_view str)
	Apply the reified string as the types specified as Arg to the Callable.
template<typename... Args, typename Callable >
constexpr decltype(auto)	apply_string (Callable &&callable, daw::string_view str, daw::string_view delemiter)
	Apply the reified string as the types specified as Args... to the Callable.
template<typename... Args, typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto)	apply_string (Callable &&callable, daw::string_view str, Splitter &&splitter)
	Apply the reified string as the types specified as Args... to the Callable.
template<typename Callable >
constexpr decltype(auto)	apply_string2 (Callable &&callable, daw::string_view str, daw::string_view delemiter)
	Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
template<typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto)	apply_string2 (Callable &&callable, daw::string_view str, Splitter &&splitter)
	Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.
template<typename Integer , typename MaskBit , typename... MaskBits>
constexpr bool	are_set (Integer value, MaskBit mask_bit, MaskBits... mask_bits) noexcept
template<typename T , typename Compare = std::equal_to<>, typename U = std::enable_if_t<std::is_array_v<remove_array_ref_t<T>>, remove_array_ref_t<T>>>
constexpr auto	array_cmp (T &&lhs, T &&rhs, Compare const &cmp=Compare{ })
template<typename From >
auto	as_char_array (From &&from) noexcept
template<typename T >
constexpr std::add_const_t< T > &	as_const (T const &t) noexcept
constexpr char	AsciiLower (char chr) noexcept
template<typename CharType , typename Traits , typename Allocator >
constexpr auto	AsciiLower (std::basic_string< CharType, Traits, Allocator > str) noexcept
constexpr char	AsciiUpper (char chr) noexcept
template<typename CharType , typename Traits , typename Allocator >
constexpr auto	AsciiUpper (std::basic_string< CharType, Traits, Allocator > str) noexcept
template<typename T , typename Rep , typename Period >
wait_status	atomic_wait_for (std::atomic< T > const *object, T const &old, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
template<typename T >
void	atomic_wait_if (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::memory_order order=std::memory_order_acquire)
template<typename T , typename Rep , typename Period >
wait_status	atomic_wait_if_for (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
template<typename T , typename Clock , typename Duration >
wait_status	atomic_wait_if_until (std::atomic< T > const *object, Fn< bool(T)> auto &&predicate, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
template<typename T , typename Clock , typename Duration >
wait_status	atomic_wait_until (std::atomic< T > const *object, T const &old, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
template<typename T >
void	atomic_wait_value_equal (std::atomic< T > const *object, T const &desired_value, std::memory_order order=std::memory_order_acquire)
template<typename T , typename Rep , typename Period >
wait_status	atomic_wait_value_equal_for (std::atomic< T > const *object, T const &desired_value, std::chrono::duration< Rep, Period > const &rel_time, std::memory_order order=std::memory_order_acquire)
template<typename T , typename Clock , typename Duration >
wait_status	atomic_wait_value_equal_until (std::atomic< T > const *object, T const &desired_value, std::chrono::time_point< Clock, Duration > const &timeout_time, std::memory_order order=std::memory_order_acquire)
template<typename Container >
	back_inserter (Container) -> back_inserter< Container >
template<typename... Chars, std::enable_if_t< daw::traits::all_same_v< char, Chars... >, std::nullptr_t > = nullptr>
	basic_bounded_string (Chars...) -> basic_bounded_string< char, sizeof...(Chars)>
template<typename CharT , size_t N>
	basic_bounded_string (CharT const (&)[N]) -> basic_bounded_string< CharT, N >
template<typename Container >
constexpr auto	begin_at (Container &container, size_t n) noexcept(noexcept(std::begin(container))) -> decltype(std::begin(container))
	Take iterator return from begin of a container and return the result of running next with n steps.
template<typename Container >
constexpr auto	begin_at (Container const &container, size_t n) noexcept(noexcept(std::cbegin(container))) -> decltype(std::cbegin(container))
	Take iterator return from begin of a container and return the result of running next with n steps.
template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto	bench_n_test (std::string const &title, Test &&test_callable, Args const &...args) noexcept
template<size_t Runs, typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds >	bench_n_test_json (Function &&func, Args &&...args) noexcept
template<size_t Runs, typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds >	bench_n_test_json_val (Validator &&validator, Function &&func, Args &&...args) noexcept
template<size_t Runs, char delem = '\n', typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto	bench_n_test_mbs (std::string const &title, size_t bytes, Test &&test_callable, Args const &...args) noexcept
template<size_t Runs, char delem = '\n', typename Validator , typename Function , typename... Args>
DAW_ATTRIB_NOINLINE std::array< double, Runs >	bench_n_test_mbs2 (std::string const &, size_t, Validator &&validator, Function &&func, Args const &...args) noexcept
template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto	bench_test (std::string const &title, Test &&test_callable, Args &&...args)
template<typename Test , typename... Args>
DAW_ATTRIB_NOINLINE auto	bench_test2 (std::string const &title, Test &&test_callable, size_t item_count, Args &&...args)
template<typename F >
DAW_ATTRIB_NOINLINE double	benchmark (F &&func)
template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void	bfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
template<typename ChildOrder = UnorderedWalk, typename T , typename Function >
void	bfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
template<typename BiDirectionalIterator >
	bidirectional_counting_iterator (BiDirectionalIterator) -> bidirectional_counting_iterator< BiDirectionalIterator >
template<std::size_t N, typename Invokable , typename... Args>
constexpr auto	bind_args_at (Invokable &&func, Args &&...args)
template<typename Function , typename... Params>
	bind_front (Function, Params...) -> bind_front< Function, Params... >
template<typename To , typename From >
To	bit_cast (From &&from) noexcept(std::is_nothrow_default_constructible_v< To >)
template<typename T = deduced_type, typename Iterator , typename OutputIterator >
void	bit_cast_copy (Iterator first, Iterator last, OutputIterator first_out)
template<typename T , typename Iterator , typename Function >
void	bit_cast_for_each (Iterator first, Iterator last, Function &&func) noexcept(noexcept(func(std::declval< T >())))
template<typename T , typename U = deduced_type, typename Iterator , typename OutputIterator , typename Function >
void	bit_cast_transform (Iterator first, Iterator last, OutputIterator first_out, Function &&func)
template<typename Value >
constexpr std::size_t	bitcount (Value value) noexcept
template<typename Value , typename... T>
constexpr std::size_t	bitcount (Value value, T... values) noexcept
template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr void	block_append_from (vector< T, Allocator > &v, InputIterator first, InputIterator last, std::size_t block_size=512)
template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>
constexpr vector< T, Allocator >	block_create_from (InputIterator first, InputIterator last, std::size_t block_size=512)
template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
	bounded_hash_map (std::pair< Key, Value > const (&&items)[N]) -> bounded_hash_map< Key, Value, N, Hash >
template<typename Key , typename Value >
	bounded_hash_map_item_t (Key, Value) -> bounded_hash_map_item_t< Key, Value >
constexpr void	breakpoint () noexcept
template<typename T , typename... Args>
constexpr bool	can_extract (std::variant< Args... > &&var) noexcept
template<typename T , typename... Args>
constexpr bool	can_extract (std::variant< Args... > const &var) noexcept
template<typename IntegerDest , typename IntegerSource >
constexpr bool	can_fit (IntegerSource const value) noexcept
template<typename T , bool AllowDownSignCast = false, typename U >
constexpr decltype(auto)	cast (U &&v)
template<typename... ExpectedExceptions, typename Function , typename... Args>
auto	checked_from_code (Function func, Args &&...args)
template<typename Iterator >
	chunk_iterator (Iterator, std::size_t) -> chunk_iterator< Iterator >
template<typename T >
constexpr auto	cibegin (T &&container) noexcept
template<typename T , size_t N>
constexpr auto	cibegin (T const (&container)[N]) noexcept
template<typename T , size_t N>
constexpr auto	cibegin (T(&container)[N]) noexcept
template<typename T >
constexpr auto	ciend (T &&container) noexcept
template<typename T , size_t N>
constexpr auto	ciend (T const (&container)[N]) noexcept
template<typename T , size_t N>
constexpr auto	ciend (T(&container)[N]) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_equal (T t, U u) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_greater (T t, U u) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_greater_equal (T t, U u) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_less (T t, U u) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_less_equal (T t, U u) noexcept
template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	cmp_not_equal (T t, U u) noexcept
template<typename T , typename Storage , typename... Args>
T *	construct_at (Storage *p, Args &&...args)
template<typename T , typename... Args>
constexpr T *	construct_at (T *p, Args &&...args)
template<typename Destination , typename ExpectedArg >
constexpr decltype(auto)	construct_from (daw::string_view str)
	Contructs an object from the arguments specified in the string using a default delemiter of " ".
template<typename Destination , typename... ExpectedArgs>
constexpr decltype(auto)	construct_from (daw::string_view str, daw::string_view delemiter)
	Contructs an object from the arguments specified in the string.
template<typename Destination , typename... ExpectedArgs, typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>
constexpr decltype(auto)	construct_from (daw::string_view str, Splitter &&splitter)
	Contructs an object from the arguments specified in the string.
template<typename Destination , typename... Args>
constexpr decltype(auto)	construct_from (std::tuple< Args... > &&args) noexcept(noexcept(daw::apply(construct_a< Destination >, std::move(args))))
template<typename Destination , typename... Args>
constexpr decltype(auto)	construct_from (std::tuple< Args... > const &args) noexcept(noexcept(daw::apply(construct_a< Destination >, args)))
template<typename Container , typename Item >
constexpr bool	contains (Container const &container, Item const &item) noexcept
template<ContiguousContainer Container>
	contiguous_view (Container &&c) -> contiguous_view< std::remove_reference_t< decltype(*std::data(c))> >
template<typename T >
	contiguous_view (T *, std::size_t) -> contiguous_view< T >
template<typename T >
	contiguous_view (T *, T *) -> contiguous_view< T >
template<typename T , std::size_t N>
	contiguous_view (T(&)[N]) -> contiguous_view< T >
DAW_ATTRIB_NOINLINE void	contract_failure ()
template<typename T >
constexpr T	copy (T &&value) noexcept(std::is_nothrow_copy_constructible< T >::value)
template<typename Iterator , typename OutputIterator >
constexpr OutputIterator	copy_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept
template<typename T >
auto	copy_ptr_value (T const *const original)
template<template< class, class > class Vector, typename T , typename A >
constexpr Vector< T, A >	copy_vector (Vector< T, A > const &container, std::size_t num_items)
template<typename Key , typename Value >
auto	create_hash_table (std::initializer_list< std::pair< Key, Value > > const &values)
template<typename T , size_t N>
constexpr void	cswap (std::array< T, N > &lhs, std::array< T, N > &rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >)
template<typename T >
constexpr void	cswap (T &&lhs, T &&rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< T >, std::is_nothrow_move_constructible< T > >)
template<typename Iterator1 , typename Iterator2 , typename OutputIterator >
constexpr OutputIterator	cxpr_copy (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out)
template<typename Iterator1 , typename Iterator2 , typename OutputIterator >
constexpr OutputIterator	cxpr_move (Iterator1 first_in, Iterator2 const last_in, OutputIterator first_out)
template<typename Container >
constexpr auto	data (Container &&c)
template<typename Container >
constexpr auto	data_end (Container &&c)
	DAW_MAKE_REQ_TRAIT (can_be_bounded_string, daw::bounded_string{ std::declval< T >() })
template<class T >
constexpr auto	decay_copy (T &&v) noexcept(is_nothrow_convertible_v< T, std::decay_t< T > >) -> std::enable_if_t< std::is_convertible_v< T, std::decay_t< T > >, std::decay_t< T > >
void	default_contract_failure ()
template<typename... >
void	deleted ()=delete
template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void	dfs_walk (daw::graph_t< T > &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
template<typename T , typename Function , typename ChildOrder = UnorderedWalk>
void	dfs_walk (daw::graph_t< T > const &graph, daw::node_id_t start_node_id, Function &&func, ChildOrder ord=ChildOrder{ })
template<typename Iterator >
constexpr ptrdiff_t	distance (Iterator first, Iterator second) noexcept(noexcept(cpp_17_details::distance_impl(first, second, typename std::iterator_traits< Iterator >::iterator_category{ })))
	Calculate distance between iterators.
template<class T >
DAW_ATTRIB_INLINE void	do_not_optimize (T const &value)
template<typename... Values, std::enable_if_t<(sizeof...(Values) !=1), std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE void	do_not_optimize (Values &&...values)
template<typename... Args>
void	dump (Args &&...args)
constexpr bool	empty_range (Range auto &&r)
template<typename Container >
constexpr auto	end_inserter (Container &c)
template<typename Container >
	end_inserter_iterator (Container) -> end_inserter_iterator< Container >
template<typename T >
constexpr utility_details::EqualToImpl< T >	equal_to (T value)
template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type	erase (vector< T, Allocator > &c, auto const &v)
template<typename T , typename Allocator >
constexpr vector< T, Allocator >::size_type	erase_if (vector< T, Allocator > &c, auto pred)
template<typename T , typename U = T>
DAW_ATTRIB_INLINE constexpr T	exchange (T &obj, U &&new_value)
template<typename... Ts>
	expander (Ts...) -> expander< Ts... >
template<typename Result , typename Function , typename... Args>
expected_t< Result >	expected_from_code (Function &&func, Args &&...args)
template<typename Function , typename... Args>
auto	expected_from_code (Function &&func, Args &&...args)
template<typename Result >
expected_t< Result >	expected_from_exception ()
template<typename Result >
expected_t< Result >	expected_from_exception (std::exception_ptr ptr)
template<typename Bool >
DAW_ATTRIB_NOINLINE constexpr void	expecting (Bool const &expected_result)
template<typename T , typename U >
DAW_ATTRIB_NOINLINE constexpr void	expecting (T &&expected_result, U &&result)
template<typename Exception = std::exception, typename Expression , typename Predicate = benchmark_impl::always_true, std::enable_if_t< std::is_invocable_v< Predicate, Exception >, std::nullptr_t > = nullptr>
DAW_ATTRIB_NOINLINE void	expecting_exception (Expression &&expression, Predicate &&pred=Predicate{ })
template<typename Bool , typename String >
DAW_ATTRIB_NOINLINE constexpr void	expecting_message (Bool &&expected_result, String &&message)
template<typename T >
constexpr auto	extract_from_container (T &container)
template<typename Iterator1 , typename Iterator2 , typename Pred >
std::vector< Iterator1 >	find_all_where (Iterator1 first, Iterator2 const last, Pred predicate)
template<typename T , typename Pred >
auto	find_all_where (T const &values, Pred predicate)
template<typename Iterator , typename Filter >
	find_iterator (Iterator, Filter) -> find_iterator< Iterator, Iterator, Filter >
template<typename Iterator , typename IteratorLast , typename Filter >
	find_iterator (Iterator, IteratorLast, Filter) -> find_iterator< Iterator, IteratorLast, Filter >
template<typename Iterator , typename IteratorLast , typename Filter >
	find_one_iterator (Iterator, IteratorLast, Filter) -> find_one_iterator< Iterator, IteratorLast, Filter >
template<typename Iterator >
	fixed_array (Iterator, std::size_t) -> fixed_array< typename std::iterator_traits< Iterator >::value_type >
template<typename... Ts>
	fixed_array (std::in_place_t, Ts...) -> fixed_array< std::common_type_t< Ts... > >
template<typename T , typename... Ts>
	fixed_array (std::in_place_type_t< T >, Ts...) -> fixed_array< T >
template<typename T >
	fixed_array (std::size_t, T) -> fixed_array< T >
template<typename Float , std::enable_if_t< std::is_floating_point_v< Float >, std::nullptr_t > = nullptr>
constexpr Float	float_abs (Float f)
template<typename T >
constexpr decltype(auto)	fmt_any (T &&v)
template<Range R>
	fmt_range (R) -> fmt_range< R >
template<Range R, typename CharT >
	fmt_range (R, CharT const *) -> fmt_range< R, CharT >
template<Range R, typename CharT >
	fmt_range (R, CharT const *, CharT const *, CharT const *) -> fmt_range< R, CharT >
template<typename T >
	fmt_tuple (T) -> fmt_tuple< T >
template<typename T , typename CharT >
	fmt_tuple (T, CharT const *) -> fmt_tuple< T, CharT >
template<typename T , typename CharT >
	fmt_tuple (T, CharT const *, CharT const *, CharT const *) -> fmt_tuple< T, CharT >
template<fnv1a_uint_t N>
constexpr fnv1a_uint_t	fnv1a_hash (char const (&ptr)[N]) noexcept
constexpr fnv1a_uint_t	fnv1a_hash (char const *ptr) noexcept
template<typename CharT >
constexpr fnv1a_uint_t	fnv1a_hash (CharT const *ptr, std::size_t len) noexcept
template<typename CharT , size_t Capacity>
constexpr size_t	fnv1a_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept
template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, std::nullptr_t > = nullptr>
constexpr fnv1a_uint_t	fnv1a_hash (Integer value) noexcept
template<typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
fnv1a_uint_t	fnv1a_hash (StringViewLike &&sv)
template<typename T >
void	force_evaluation (T &value)
template<typename T >
void	force_evaluation (T const &value)
template<typename... Ts>
constexpr tuple< Ts &&... >	forward_as_tuple (Ts &&...ts) noexcept
template<typename... Ts>
constexpr tuple2< Ts... >	forward_as_tuple2 (Ts &&...args)
template<typename ForwardIterator >
	forward_counting_iterator (ForwardIterator) -> forward_counting_iterator< ForwardIterator >
template<typename... Ts>
constexpr auto	forward_nonrvalue_as_tuple (Ts &&...values)
	Forwards arguments but stores rvalues. This allows use to prevent dangling ref's.
template<typename... Ts>
constexpr auto	forward_nontemp_as_tuple (Ts &&...values)
template<std::size_t Idx, typename... Ts>
constexpr decltype(auto)	forward_nth_pack_element (Ts &&...values)
template<typename Function >
	function_iterator (Function) -> function_iterator< Function >
template<typename... Ts>
	fwd_pack (Ts &&...) -> fwd_pack< Ts &&... >
template<size_t HashBytes = sizeof( genhash_uint_t ), std::size_t N>
constexpr auto	generic_hash (char const (&ptr)[N]) noexcept
template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t	generic_hash (daw::basic_bounded_string< CharT, Capacity > const &str) noexcept
template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>
constexpr size_t	generic_hash (daw::basic_bounded_string< CharT, Capacity > sv) noexcept
template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator , typename IteratorL >
constexpr auto	generic_hash (Iterator first, IteratorL const last) noexcept
template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator >
constexpr auto	generic_hash (Iterator first, std::size_t const len) noexcept
template<size_t HashBytes = sizeof( genhash_uint_t ), typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>
auto	generic_hash (StringViewLike const &&sv) noexcept
template<size_t HashBytes = sizeof( genhash_uint_t ), typename T , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr auto	generic_hash (T const value) noexcept
template<std::size_t Idx, typename... Ts>
constexpr decltype(auto)	get (fwd_pack< Ts... > &&p)
template<std::size_t Idx, typename... Ts>
constexpr decltype(auto)	get (fwd_pack< Ts... > &p)
template<std::size_t Idx, typename... Ts>
constexpr decltype(auto)	get (fwd_pack< Ts... > const &p)
template<typename... Args>
constexpr auto	get (std::tuple< Args... > &tp, size_t index) noexcept
template<typename... Args>
constexpr auto	get (std::tuple< Args... > const &tp, size_t index) noexcept
template<std::size_t Index, typename Ts >
constexpr Ts &&	get (tuple2_impl::leaf< Index, Ts, false > &&tp)
template<std::size_t Index, typename Ts >
constexpr Ts &	get (tuple2_impl::leaf< Index, Ts, false > &tp)
template<std::size_t Index, typename Ts >
constexpr Ts const &&	get (tuple2_impl::leaf< Index, Ts, false > const &&tp)
template<std::size_t Index, typename Ts >
constexpr Ts const &	get (tuple2_impl::leaf< Index, Ts, false > const &tp)
template<std::size_t Index, typename Ts >
constexpr Ts &&	get (tuple2_impl::leaf< Index, Ts, true > &&tp)
template<std::size_t Index, typename Ts >
constexpr Ts &	get (tuple2_impl::leaf< Index, Ts, true > &tp)
template<std::size_t Index, typename Ts >
constexpr Ts const &&	get (tuple2_impl::leaf< Index, Ts, true > const &&tp)
template<std::size_t Index, typename Ts >
constexpr Ts const &	get (tuple2_impl::leaf< Index, Ts, true > const &tp)
template<std::size_t N, typename... Ts>
constexpr decltype(auto)	get (tuple< Ts... > &&tp)
template<std::size_t N, typename... Ts>
constexpr decltype(auto)	get (tuple< Ts... > &tp)
template<std::size_t N, typename... Ts>
constexpr decltype(auto)	get (tuple< Ts... > const &tp)
template<size_t N, typename... T>
constexpr decltype(auto)	get (zip_iterator< T... > &zi) noexcept
template<size_t N, typename... T>
constexpr decltype(auto)	get (zip_iterator< T... > const &zi) noexcept
template<unsigned N>
constexpr UInt16	get_bit (UInt16 value)
template<unsigned N>
constexpr UInt32	get_bit (UInt32 value)
template<unsigned N>
constexpr UInt64	get_bit (UInt64 value)
template<unsigned N>
constexpr UInt8	get_bit (UInt8 value)
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer	get_bits (Integer i, Bit b, Bits... bs) noexcept
	get value with all bits but those specified masked out
template<typename T , std::size_t Alignment = alignof( T )>
T *	get_buffer (std::size_t count) noexcept
	aligned_alloc is not in clang-cl 13 with vs2022
template<typename T >
constexpr T	get_left_mask (size_t left_zero_bits) noexcept
template<std::size_t Idx, typename Variant >
constexpr decltype(auto)	get_nt (Variant &&var)
template<typename T >
constexpr T	get_right_mask (size_t right_zero_bits) noexcept
template<typename OutputIterator >
constexpr OutputIterator	hex (char c, OutputIterator it_out) noexcept
template<size_t N, typename OutputIterator >
constexpr OutputIterator	hex (char const (&str)[N], OutputIterator first_out) noexcept
template<typename OutputIterator >
constexpr OutputIterator	hex (char const *str, std::size_t len, OutputIterator first_out) noexcept
template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
constexpr OutputIterator	hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept
template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>
OutputIterator	hex (ForwardIterator1 first_in, ForwardIterator2 const last_in, OutputIterator first_out) noexcept
template<typename T , typename OutputIterator , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr OutputIterator	hex (T const &val, OutputIterator it_out) noexcept
template<typename T , typename OutputIterator , std::enable_if_t< not std::is_integral_v< T >, std::nullptr_t > = nullptr>
OutputIterator	hex (T const &val, OutputIterator it_out) noexcept
template<typename OutputIterator >
constexpr OutputIterator	hex_lc (char c, OutputIterator it_out) noexcept
template<typename T >
constexpr auto	ibegin (T &&container) noexcept
template<typename T , size_t N>
constexpr auto	ibegin (T const (&container)[N]) noexcept
template<typename T , size_t N>
constexpr auto	ibegin (T(&container)[N]) noexcept
template<typename T >
constexpr auto	iend (T &&container) noexcept
template<typename T , size_t N>
constexpr auto	iend (T const (&container)[N]) noexcept
template<typename T , size_t N>
constexpr auto	iend (T(&container)[N]) noexcept
template<typename R , typename T , std::enable_if_t< daw::is_integral_v< R > and daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	in_range (T t) noexcept
template<typename Value , typename LowerBound , typename UpperBound >
constexpr bool	in_range (Value &&value, LowerBound &&lower, UpperBound &&upper) noexcept(noexcept(lower<=value &&value< upper))
	Checks if value is in the range [lower, upper)
template<typename Container , typename Item >
constexpr auto	index_of (Container const &container, Item const &item) noexcept
template<typename Iterator >
	InputIterator (Iterator) -> InputIterator< typename std::iterator_traits< Iterator >::value_type >
template<typename Container >
	InputRange (Container) -> InputRange< std::remove_reference_t< decltype(*std::begin(std::declval< Container >()))> >
template<typename Iterator >
	InputRange (Iterator, Iterator) -> InputRange< typename std::iterator_traits< Iterator >::value_type >
template<typename Container , typename Allocator , typename Pointer >
constexpr void	insert_into_container (Container &vec, Pointer *buff, Allocator alloc, std::size_t capacity, std::size_t size)
template<typename Container >
constexpr auto	inserter (Container &c)
template<typename F , typename... Args, std::enable_if_t< sizeof...(Args) !=1 or((not is_reference_wrapper_v< Args >) and ...), std::nullptr_t > = nullptr>
constexpr decltype(auto)	invoke (F &&f, Args &&...args) noexcept(std::is_nothrow_invocable_v< F, Args... >)
template<typename F , typename Arg , typename... Args>
constexpr decltype(auto)	invoke (F &&f, std::reference_wrapper< Arg > arg, std::reference_wrapper< Args >... args) noexcept(std::is_nothrow_invocable_v< F, Args... >)
	iota_iterator () -> iota_iterator< int >
template<typename T , typename... Step>
	iota_iterator (T, Step...) -> iota_iterator< T >
	iota_range () -> iota_range< int >
template<typename T , typename... EndStep>
	iota_range (T, EndStep...) -> iota_range< T >
constexpr bool	is_space (char chr) noexcept
template<typename R >
constexpr auto	iter_last (R &&r)
template<typename ForwardIterator1 , typename ForwardIterator2 >
constexpr void	iter_swap (ForwardIterator1 lhs, ForwardIterator2 rhs) noexcept(std::conjunction_v< std::is_nothrow_move_assignable< decltype(*lhs)>, std::is_nothrow_move_assignable< decltype(*rhs)> >)
template<typename Container >
	iter_view (Container) -> iter_view< typename Container::iterator >
template<typename ForwardIterator , typename Last >
	iter_view (ForwardIterator, Last) -> iter_view< ForwardIterator, Last >
template<typename T , std::size_t N>
	iter_view (T(&&)[N]) -> iter_view< T * >
template<typename T , std::size_t N>
	iter_view (T(&)[N]) -> iter_view< T * >
template<typename T = make_array_impl::unspecified_type, typename... Args, std::enable_if_t< not std::is_same_v< T, void >, std::nullptr_t > = nullptr>
constexpr auto	make_array (Args &&...args)
template<typename T , size_t N>
constexpr auto	make_array (T const (&&arry)[N])
template<typename Iterator >
constexpr auto	make_bit_iterator (Iterator &&it)
	Create a bit_iterator with supplied bit.
template<typename BitQueueLSB = bit_queue_source_native_endian, typename InputIteratorF , typename InputIteratorL >
constexpr auto	make_bit_stream (InputIteratorF first, InputIteratorL last) noexcept
template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>
DAW_CONSTEVAL auto	make_bounded_hash_map (std::pair< Key, Value > const (&items)[N])
template<typename Key , typename Hash = std::hash<Key>, size_t N>
constexpr auto	make_bounded_hash_set (Key const (&items)[N]) noexcept
template<size_t Capacity = 100, typename CharT , size_t N>
constexpr daw::basic_bounded_string< CharT, Capacity >	make_bounded_string (CharT const (&str)[N])
template<size_t Capacity = 100, typename Container >
constexpr auto	make_bounded_string (Container const &v) noexcept -> basic_bounded_string< typename Container::value_type, Capacity >
template<size_t Capacity = 100, typename CharT >
constexpr auto	make_bounded_string_it (CharT const *first, CharT const *last) noexcept
template<size_t Capacity = 100, typename Iterator , typename CharT = DAW_TYPEOF( *std::declval<Iterator>( ) )>
constexpr auto	make_bounded_string_it (Iterator first, Iterator last) noexcept
template<typename Function , std::enable_if_t< not std::is_function_v< std::remove_reference_t< Function > >, std::nullptr_t > = nullptr>
constexpr decltype(auto)	make_callable (Function &&func) noexcept
template<typename Function , std::enable_if_t< std::is_function_v< Function >, std::nullptr_t > = nullptr>
constexpr auto	make_callable (Function *func) noexcept
template<typename Result , typename... Exceptions, typename Function >
constexpr checked_function_t< Function, Result, Exceptions... >	make_checked_function (Function &&func) noexcept
template<typename IteratorFirst , typename IteratorLast >
auto	make_checked_iterator_proxy (IteratorFirst first, IteratorLast last, bool CheckIncrement=true, bool CheckDecrement=true, bool CheckDereference=true)
template<typename Container >
constexpr auto	make_circular_iterator (Container &container) noexcept
template<typename Container , typename Iterator >
constexpr auto	make_circular_iterator (Container &container, Iterator it) noexcept
template<typename T >
constexpr auto	make_const_random_iterator (T *const ptr) noexcept
template<typename T , typename... Args>
copiable_unique_ptr< T >	make_copiable_unique_ptr (Args &&...args) noexcept(std::is_nothrow_constructible_v< T, Args... >)
template<typename Value , size_t HashSize = sizeof( size_t ), typename... Keys>
constexpr auto	make_fixed_lookup (Keys &&...keys) noexcept
template<size_t N>
constexpr auto	make_formatter (char const (&str)[N])
template<class T , class Tuple >
constexpr T	make_from_tuple2 (Tuple &&t)
template<typename L >
constexpr function_traits_t< L >	make_function (L l) noexcept
template<typename ReturnType , typename... Args>
std::function< ReturnType(Args...)>	make_function (ReturnType(*p)(Args...))
template<typename ReturnType , typename... Args>
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)>	make_function (ReturnType(*p)(Args...))
template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)>	make_function (ReturnType(ClassType::*p)(Args...))
template<typename ReturnType , typename... Args, typename ClassType >
std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)>	make_function (ReturnType(ClassType::*p)(Args...))
template<typename ReturnType , typename... Args, class T >
auto	make_function (T &&t) -> std::function< decltype(ReturnType(t(std::declval< Args >()...)))(Args...)>
template<typename Function >
constexpr auto	make_function_iterator (Function &&func)
	Create a function_iterator with supplied function.
template<typename R = void, typename Function , typename... Functions>
constexpr function_table_t< R, Function, Functions... >	make_function_table (Function fn, Functions... fns)
template<typename Arg , typename... Args>
auto	make_initializer_list (Arg &&arg, Args &&...args)
template<typename Bit , typename... Bits>
constexpr auto	make_mask (Bit bit, Bits... bits) noexcept
template<typename Iterator >
constexpr std::move_iterator< Iterator >	make_move_iterator (Iterator &&i)
template<typename T , typename... Args>
auto	make_optional_poly (Args &&...args)
template<typename OutputStream >
constexpr function_iterator< osi_impl::osi_callable< OutputStream > >	make_output_stream_iterator (OutputStream &strm)
template<typename Hasher , typename Key , typename Value , size_t N>
constexpr auto	make_perfect_hash_table (std::pair< Key, Value > const (&data)[N])
template<typename IntType , typename Result = std::vector<IntType>>
Result	make_random_data (std::size_t count, IntType a=lowest_value< IntType >, IntType b=max_value< IntType >)
template<typename T >
constexpr auto	make_random_iterator (T *const ptr) noexcept
template<typename Iterator >
constexpr auto	make_range (Iterator first, Iterator last) noexcept
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T >	make_rc_ptr (Args &&...args)
template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T >	make_rc_ptr (std::size_t size)
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T >	make_rc_ptr_for_overwrite (Args &&...)=delete
template<typename T >
DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T >	make_rc_ptr_for_overwrite (std::size_t size)
template<typename Iterator >
constexpr reverse_iterator< Iterator >	make_reverse_iterator (Iterator i)
template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto	make_reverse_topological_sorted_range (Graph &&g, Compare c=Compare{ })
template<typename L >
constexpr auto	make_root_function (L l) noexcept
template<typename ReturnType , typename... Args, class T >
auto	make_root_function (T &&t) -> std::function< decltype(daw::traits::root_type_t< ReturnType >(t(std::declval< daw::traits::root_type_t< Args > >()...)))(Args...)>
template<typename SanitizeFunction , typename charT , typename traits = std::char_traits<charT>, typename Alloc = std::allocator<charT>>
auto	make_safe_string (charT const *const unsafe_cstring, SanitizeFunction &&sanitize_function)
template<typename SanitizeFunction , typename charT , typename traits , typename Alloc >
auto	make_safe_string (std::basic_string< charT, traits, Alloc > unsafe_string, SanitizeFunction &&sanitize_function)
template<typename... Args, typename Compare = std::less<>>
auto	make_sorted_insert_iterator (std::deque< Args... > &c, Compare compare=Compare{ })
template<typename... Args, typename Compare = std::less<>>
decltype(auto)	make_sorted_insert_iterator (std::list< Args... > &c, Compare compare=Compare{ })
template<typename... Args, typename Compare = std::less<>>
auto	make_sorted_insert_iterator (std::vector< Args... > &c, Compare compare=Compare{ })
template<typename CharT , typename Traits , typename Allocator >
constexpr auto	make_split_it (std::basic_string< CharT, Traits, Allocator > &str, CharT divider) noexcept
template<typename String , typename Splitter , daw::required< impl::is_splitter_v< Splitter, String > > = nullptr>
constexpr auto	make_split_it (String &sv, Splitter &&splitter) noexcept
template<typename ReturnType , typename... Args, typename ClassType >
std::function< ReturnType(Args...)>	make_std_function (ReturnType(ClassType::*p)(Args...))
template<typename... Ts>
std::array< std::string, sizeof...(Ts)>	make_string_array (Ts &&...t)
template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>
auto	make_topological_sorted_range (Graph &&g, Compare c=Compare{ })
template<typename... Ts>
constexpr tuple< make_tuple_details::unwrap_decay_t< Ts >... >	make_tuple (Ts &&...args)
template<typename T , typename... Args>
DAW_CPP20_CX_ALLOC auto	make_unique (Args &&...args) -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > >
template<typename T >
DAW_CPP20_CX_ALLOC auto	make_unique (std::size_t count) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > >
template<typename T , typename... Elements>
DAW_CPP20_CX_ALLOC auto	make_unique_array (Elements &&...elements) -> std::enable_if_t< std::is_array_v< T >, unique_ptr< T > >
template<typename T >
DAW_CPP20_CX_ALLOC auto	make_unique_for_overwrite () -> std::enable_if_t< not std::is_array_v< T >, unique_ptr< T > >
template<typename Function >
constexpr auto	make_void_function (Function &&func) noexcept(noexcept(traits_details::void_function< Function >(DAW_FWD(func))))
template<typename... Containers>
zip_container< Containers... >	make_zipcontainer (Containers &&...args)
template<typename T >
constexpr T	mask_lsb (size_t bit_count) noexcept
template<typename T >
constexpr T	mask_msb (size_t bit_count) noexcept
template<typename T , typename... Ts>
constexpr auto()	max (T const &val1, Ts const &...vs) noexcept
template<typename T , typename Compare = math_impl::less>
constexpr decltype(auto)	max_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ })
template<typename T , typename... Ts>
constexpr auto()	min (T const &val1, Ts const &...vs) noexcept
template<typename T , typename Compare = math_impl::less>
constexpr decltype(auto)	min_comp (T &&lhs, T &&rhs, Compare &&comp=Compare{ })
template<typename T >
constexpr daw::traits::remove_reference_t< T > &&	move (T &&value) noexcept
	Convert a value to an rvalue.
template<typename Iterator , typename OutputIterator >
constexpr OutputIterator	move_n (Iterator first, std::size_t sz, OutputIterator out_it) noexcept
template<typename T >
	move_only (T) -> move_only< T >
template<typename T , typename Compare = daw::graph_alg_impl::NoSort>
void	mst (daw::graph_t< T > &graph, Compare=Compare{ })
template<typename T >
	mutable_capture (T) -> mutable_capture< T >
template<typename Integer , typename... Ts, typename T >
constexpr Integer	narrow_cast (T value)
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T	network_to_host_endian (T value) noexcept
template<typename Iterator >
constexpr Iterator	next (Iterator it, ptrdiff_t n=1) noexcept
	Move iterator forward n steps, if n < 0 it is only defined for types that are Bidirectional.
template<typename... Ts>
constexpr auto	none_of_f (Ts &&...needles) noexcept
template<typename Function >
constexpr utility_details::NotImpl< Function >	Not (Function func)
template<typename Function >
constexpr auto	not_fn ()
template<typename Function >
constexpr auto	not_fn (Function &&func)
template<typename Pointer >
	not_null (never_null_t, not_null< Pointer >) -> not_null< Pointer >
template<typename Pointer >
	not_null (never_null_t, Pointer) -> not_null< Pointer >
template<typename Pointer >
	not_null (not_null< Pointer >) -> not_null< Pointer >
template<typename Pointer >
	not_null (Pointer) -> not_null< Pointer >
template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool	nsc_and (Bool lhs, Bools... rhs) noexcept
	Explicitly do a non-short circuiting logical and with bitwise and.
template<typename Bool , typename... Bools>
DAW_ATTRIB_INLINE constexpr bool	nsc_or (Bool lhs, Bools... rhs) noexcept
	Explicitly do a non-short circuiting logical or with bitwise or.
template<std::size_t Idx, typename... Ts>
constexpr auto	nth_pack_element (Ts &&...values)
template<typename P >
	observer_ptr (P *) -> observer_ptr< P >
template<typename Obj , typename T >
constexpr std::size_t	offset_of (T Obj::*Mem)
template<typename Handler >
	on_exit_success (Handler) -> on_exit_success< Handler >
template<typename FunctionType >
DAW_ATTRIB_INLINE constexpr ScopeGuard< FunctionType >	on_scope_exit (FunctionType f) noexcept(std::is_nothrow_move_constructible_v< FunctionType >)
constexpr bool	operator! (UInt16 value)
constexpr bool	operator! (UInt32 value)
constexpr bool	operator! (UInt64 value)
constexpr bool	operator! (UInt8 value)
template<typename T , typename U , size_t N>
constexpr bool	operator!= (array< T, N > const &lhs, array< U, N > const &rhs)
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator!= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename Key , typename Value >
constexpr bool	operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key , typename Value >
constexpr bool	operator!= (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key >
constexpr bool	operator!= (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename Key >
constexpr bool	operator!= (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator!= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename Key , typename Value >
constexpr bool	operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key , typename Value >
constexpr bool	operator!= (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key >
constexpr bool	operator!= (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename Key >
constexpr bool	operator!= (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator!= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator!= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator!= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator!= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator!= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator!= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator!= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator!= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator!= (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator!= (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept
template<typename T >
constexpr bool	operator!= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator!= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
constexpr bool	operator!= (node_id_t const &lhs, node_id_t const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator!= (optional< T > const &lhs, optional< U > const &rhs)
template<typename T >
constexpr bool	operator!= (optional< T > const &opt, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator!= (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator!= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator!= (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename CharT >
constexpr bool	operator!= (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator!= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename Iterator >
constexpr bool	operator!= (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator!= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator!= (std::nullopt_t, optional< T > const &opt) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator!= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
constexpr bool	operator!= (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator!= (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr bool	operator!= (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator!= (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename CharT >
constexpr bool	operator!= (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator!= (T const &value, optional< U > const &opt)
template<typename CharT , size_t Capacity>
constexpr bool	operator!= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator!= (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator!= (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr bool	operator!= (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator!= (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator!= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_inequality< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator!= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs != *rhs))
constexpr UInt16	operator""_u16 (unsigned long long value)
constexpr UInt32	operator""_u32 (unsigned long long value)
constexpr UInt64	operator""_u64 (unsigned long long value)
constexpr UInt8	operator""_u8 (unsigned long long value)
constexpr UInt16	operator& (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator& (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt64	operator& (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator& (std::uint8_t lhs, UInt8 rhs) noexcept
constexpr UInt16	operator& (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator& (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator& (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator& (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator& (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator& (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator& (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator& (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator& (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator& (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator& (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator& (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator& (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator& (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator& (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator& (UInt8 lhs, std::uint8_t rhs) noexcept
constexpr UInt32	operator& (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator& (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator& (UInt8 lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator&= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator&= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator&= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator&= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator&= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator&= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator&= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator&= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator&= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator&= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator&= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator&= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator&= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator&= (UInt8 &lhs, UInt8 rhs) noexcept
constexpr UInt16	operator* (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator* (std::uint32_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator* (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt32	operator* (std::uint32_t lhs, UInt8 rhs) noexcept
constexpr UInt64	operator* (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator* (std::uint8_t lhs, UInt64 rhs) noexcept
constexpr UInt16	operator* (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator* (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator* (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator* (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator* (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator* (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator* (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator* (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator* (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator* (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator* (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator* (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator* (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator* (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator* (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt16	operator* (UInt8 lhs, std::uint16_t rhs) noexcept
constexpr UInt8	operator* (UInt8 lhs, std::uint64_t rhs) noexcept
constexpr UInt16	operator* (UInt8 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator* (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator* (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator* (UInt8 lhs, UInt8 rhs) noexcept
constexpr std::uint16_t &	operator*= (std::uint16_t &lhs, UInt16 rhs) noexcept
constexpr std::uint16_t &	operator*= (std::uint16_t &lhs, UInt8 rhs) noexcept
constexpr std::uint32_t &	operator*= (std::uint32_t &lhs, UInt16 rhs) noexcept
constexpr std::uint32_t &	operator*= (std::uint32_t &lhs, UInt32 rhs) noexcept
constexpr std::uint32_t &	operator*= (std::uint32_t &lhs, UInt8 rhs) noexcept
constexpr std::uint64_t &	operator*= (std::uint64_t &lhs, UInt64 rhs) noexcept
constexpr std::uint8_t &	operator*= (std::uint8_t &lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator*= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator*= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator*= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator*= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator*= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator*= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator*= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator*= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator*= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator*= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator*= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator*= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator*= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator*= (UInt8 &lhs, UInt8 rhs) noexcept
template<typename CharT , size_t Capacity>
auto	operator+ (CharT const *lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs)
template<typename CharT , size_t N, size_t Capacity>
auto	operator+ (CharT(&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs)
template<typename T >
not_null< T >	operator+ (const not_null< T > &, std::ptrdiff_t)=delete
template<typename CharT , size_t Capacity>
auto	operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT const *rhs)
template<typename CharT , size_t Capacity, size_t N>
auto	operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, CharT(&rhs)[N])
template<typename CharT , size_t Capacity, typename Allocator >
auto	operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > &&rhs)
template<typename CharT , size_t Capacity, typename Allocator >
auto	operator+ (daw::basic_bounded_string< CharT, Capacity > lhs, std::basic_string< CharT, Allocator > const &rhs)
template<typename CharT , size_t Capacity, typename Allocator >
auto	operator+ (std::basic_string< CharT, Allocator > lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs)
	Appending.
template<typename Iterator1 , typename Tag >
constexpr wrap_iter< Iterator1, Tag >	operator+ (std::ptrdiff_t n, wrap_iter< Iterator1, Tag > x) noexcept
template<typename T >
not_null< T >	operator+ (std::ptrdiff_t, const not_null< T > &)=delete
constexpr UInt16	operator+ (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator+ (std::uint32_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator+ (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt32	operator+ (std::uint32_t lhs, UInt8 rhs) noexcept
constexpr UInt64	operator+ (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator+ (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename Iterator >
constexpr reverse_iterator< Iterator >	operator+ (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it)
constexpr UInt16	operator+ (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt32	operator+ (UInt16 lhs, std::uint32_t rhs) noexcept
constexpr UInt16	operator+ (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator+ (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator+ (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator+ (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt16	operator+ (UInt16 value)
constexpr UInt32	operator+ (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator+ (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator+ (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator+ (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator+ (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator+ (UInt32 value)
constexpr UInt64	operator+ (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator+ (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator+ (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator+ (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator+ (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator+ (UInt64 value)
constexpr UInt16	operator+ (UInt8 lhs, std::uint16_t rhs) noexcept
constexpr UInt32	operator+ (UInt8 lhs, std::uint32_t rhs) noexcept
constexpr UInt8	operator+ (UInt8 lhs, std::uint8_t rhs) noexcept
constexpr UInt16	operator+ (UInt8 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator+ (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator+ (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator+ (UInt8 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator+ (UInt8 value)
constexpr UInt16 &	operator++ (UInt16 &value)
constexpr UInt16	operator++ (UInt16 &value, int)
constexpr UInt32 &	operator++ (UInt32 &value)
constexpr UInt32	operator++ (UInt32 &value, int)
constexpr UInt64 &	operator++ (UInt64 &value)
constexpr UInt64	operator++ (UInt64 &value, int)
constexpr UInt8 &	operator++ (UInt8 &value)
constexpr UInt8	operator++ (UInt8 &value, int)
constexpr std::uint16_t &	operator+= (std::uint16_t &lhs, UInt16 rhs) noexcept
constexpr std::uint16_t &	operator+= (std::uint16_t &lhs, UInt8 rhs) noexcept
constexpr std::uint32_t &	operator+= (std::uint32_t &lhs, UInt16 rhs) noexcept
constexpr std::uint32_t &	operator+= (std::uint32_t &lhs, UInt32 rhs) noexcept
constexpr std::uint32_t &	operator+= (std::uint32_t &lhs, UInt8 rhs) noexcept
constexpr std::uint64_t &	operator+= (std::uint64_t &lhs, UInt64 rhs) noexcept
constexpr std::uint8_t &	operator+= (std::uint8_t &lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator+= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator+= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator+= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator+= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator+= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator+= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator+= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator+= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator+= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator+= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator+= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator+= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator+= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator+= (UInt8 &lhs, UInt8 rhs) noexcept
template<typename T , typename U >
std::ptrdiff_t	operator- (const not_null< T > &, const not_null< U > &)=delete
template<typename T >
not_null< T >	operator- (const not_null< T > &, std::ptrdiff_t)=delete
template<class Iterator1 , class Iterator2 >
constexpr auto	operator- (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs) -> decltype(rhs.base() - lhs.base())
constexpr UInt16	operator- (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt16	operator- (std::uint16_t lhs, UInt8 rhs) noexcept
constexpr UInt32	operator- (std::uint32_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator- (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt32	operator- (std::uint32_t lhs, UInt8 rhs) noexcept
constexpr UInt64	operator- (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator- (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename Iterator >
constexpr reverse_iterator< Iterator >	operator- (typename reverse_iterator< Iterator >::difference_type n, reverse_iterator< Iterator > const &it)
constexpr UInt16	operator- (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator- (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator- (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator- (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator- (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt16	operator- (UInt16 value)
constexpr UInt32	operator- (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator- (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator- (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator- (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator- (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator- (UInt32 value)
constexpr UInt64	operator- (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator- (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator- (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator- (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator- (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator- (UInt64 value)
constexpr UInt8	operator- (UInt8 lhs, std::uint8_t rhs) noexcept
constexpr UInt16	operator- (UInt8 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator- (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator- (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator- (UInt8 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator- (UInt8 value)
template<typename Iterator1 , class Iterator2 , typename Tag >
constexpr auto	operator- (wrap_iter< Iterator1, Tag > const &x, wrap_iter< Iterator2, Tag > const &y) noexcept
constexpr UInt16 &	operator-- (UInt16 &value)
constexpr UInt16	operator-- (UInt16 &value, int)
constexpr UInt32 &	operator-- (UInt32 &value)
constexpr UInt32	operator-- (UInt32 &value, int)
constexpr UInt64 &	operator-- (UInt64 &value)
constexpr UInt64	operator-- (UInt64 &value, int)
constexpr UInt8 &	operator-- (UInt8 &value)
constexpr UInt8	operator-- (UInt8 &value, int)
constexpr std::uint16_t &	operator-= (std::uint16_t &lhs, UInt16 rhs) noexcept
constexpr std::uint16_t &	operator-= (std::uint16_t &lhs, UInt8 rhs) noexcept
constexpr std::uint32_t &	operator-= (std::uint32_t &lhs, UInt16 rhs) noexcept
constexpr std::uint32_t &	operator-= (std::uint32_t &lhs, UInt32 rhs) noexcept
constexpr std::uint32_t &	operator-= (std::uint32_t &lhs, UInt8 rhs) noexcept
constexpr std::uint64_t &	operator-= (std::uint64_t &lhs, UInt64 rhs) noexcept
constexpr std::uint8_t &	operator-= (std::uint8_t &lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator-= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator-= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator-= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator-= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator-= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator-= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator-= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator-= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator-= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator-= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator-= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator-= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator-= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator-= (UInt8 &lhs, UInt8 rhs) noexcept
constexpr UInt16	operator/ (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt16	operator/ (std::uint16_t lhs, UInt8 rhs) noexcept
constexpr UInt32	operator/ (std::uint32_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator/ (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt32	operator/ (std::uint32_t lhs, UInt8 rhs) noexcept
constexpr UInt64	operator/ (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr UInt64	operator/ (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr UInt64	operator/ (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt64	operator/ (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr UInt8	operator/ (std::uint8_t lhs, UInt64 rhs) noexcept
constexpr UInt16	operator/ (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator/ (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator/ (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator/ (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator/ (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator/ (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator/ (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator/ (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator/ (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator/ (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator/ (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator/ (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator/ (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator/ (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator/ (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator/ (UInt8 lhs, std::uint64_t rhs) noexcept
constexpr UInt16	operator/ (UInt8 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator/ (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator/ (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator/ (UInt8 lhs, UInt8 rhs) noexcept
constexpr std::uint16_t &	operator/= (std::uint16_t &lhs, UInt16 rhs) noexcept
constexpr std::uint16_t &	operator/= (std::uint16_t &lhs, UInt8 rhs) noexcept
constexpr std::uint32_t &	operator/= (std::uint32_t &lhs, UInt32 rhs) noexcept
constexpr std::uint64_t &	operator/= (std::uint64_t &lhs, UInt16 rhs) noexcept
constexpr std::uint64_t &	operator/= (std::uint64_t &lhs, UInt32 rhs) noexcept
constexpr std::uint64_t &	operator/= (std::uint64_t &lhs, UInt64 rhs) noexcept
constexpr std::uint64_t &	operator/= (std::uint64_t &lhs, UInt8 rhs) noexcept
constexpr std::uint8_t &	operator/= (std::uint8_t &lhs, UInt64 rhs) noexcept
constexpr UInt16 &	operator/= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator/= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator/= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator/= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator/= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator/= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator/= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator/= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator/= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator/= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator/= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator/= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator/= (UInt8 &lhs, std::uint64_t rhs) noexcept
constexpr UInt8 &	operator/= (UInt8 &lhs, UInt8 rhs) noexcept
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator< (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator< (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator< (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator< (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator< (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator< (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator< (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator< (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator< (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator< (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator< (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T >
constexpr bool	operator< (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator< (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
constexpr bool	operator< (node_id_t const &lhs, node_id_t const &rhs) noexcept
template<typename T >
constexpr bool	operator< (optional< T > const &, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator< (optional< T > const &lhs, optional< U > const &rhs)
template<typename T , typename U >
constexpr bool	operator< (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator< (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator< (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator< (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator< (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator< (std::nullopt_t, optional< T > const &opt) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator< (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept
constexpr bool	operator< (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator< (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr bool	operator< (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr bool	operator< (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr bool	operator< (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator< (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr bool	operator< (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename T , typename U >
constexpr bool	operator< (T const &value, optional< U > const &opt)
template<typename CharT , size_t Capacity>
constexpr bool	operator< (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator< (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator< (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr bool	operator< (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator< (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator< (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator< (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs< *rhs))
template<typename OStream , typename CharT , size_t Capacity, std::enable_if_t< daw::traits::is_ostream_like_v< OStream, CharT >, std::nullptr_t > = nullptr>
OStream &	operator<< (OStream &os, daw::basic_bounded_string< CharT, Capacity > const &str)
template<typename OStream , typename T , std::enable_if_t< daw::traits::is_ostream_like_lite_v< OStream >, std::nullptr_t > = nullptr>
OStream &	operator<< (OStream &os, Reference< T > const &ref)
template<size_t BitWidth>
std::ostream &	operator<< (std::ostream &os, static_bitset< BitWidth > const &bs)
std::ostream &	operator<< (std::ostream &os, UInt16 rhs)
std::ostream &	operator<< (std::ostream &os, UInt32 rhs)
std::ostream &	operator<< (std::ostream &os, UInt64 rhs)
std::ostream &	operator<< (std::ostream &os, UInt8 rhs)
constexpr std::uint16_t	operator<< (std::uint16_t b, UInt16 shift) noexcept
constexpr std::uint32_t	operator<< (std::uint32_t b, UInt32 shift) noexcept
constexpr std::uint64_t	operator<< (std::uint64_t b, UInt16 shift) noexcept
constexpr std::uint64_t	operator<< (std::uint64_t b, UInt32 shift) noexcept
constexpr std::uint64_t	operator<< (std::uint64_t b, UInt64 shift) noexcept
constexpr std::uint64_t	operator<< (std::uint64_t b, UInt8 shift) noexcept
constexpr std::uint8_t	operator<< (std::uint8_t b, UInt8 shift) noexcept
constexpr UInt16	operator<< (UInt16 b, std::uint16_t shift) noexcept
constexpr UInt16	operator<< (UInt16 b, UInt16 shift) noexcept
constexpr UInt16	operator<< (UInt16 b, UInt8 shift) noexcept
constexpr UInt32	operator<< (UInt32 b, std::uint32_t shift) noexcept
constexpr UInt32	operator<< (UInt32 b, UInt16 shift) noexcept
constexpr UInt32	operator<< (UInt32 b, UInt32 shift) noexcept
constexpr UInt32	operator<< (UInt32 b, UInt8 shift) noexcept
constexpr UInt64	operator<< (UInt64 b, std::uint64_t shift) noexcept
constexpr UInt64	operator<< (UInt64 b, UInt16 shift) noexcept
constexpr UInt64	operator<< (UInt64 b, UInt32 shift) noexcept
constexpr UInt64	operator<< (UInt64 b, UInt64 shift) noexcept
constexpr UInt64	operator<< (UInt64 b, UInt8 shift) noexcept
constexpr UInt8	operator<< (UInt8 b, std::uint8_t shift) noexcept
constexpr UInt8	operator<< (UInt8 b, UInt8 shift) noexcept
constexpr UInt16 &	operator<<= (UInt16 &b, std::uint16_t shift) noexcept
constexpr UInt16 &	operator<<= (UInt16 &b, UInt16 shift) noexcept
constexpr UInt16 &	operator<<= (UInt16 &b, UInt8 shift) noexcept
constexpr UInt32 &	operator<<= (UInt32 &b, std::uint32_t shift) noexcept
constexpr UInt32 &	operator<<= (UInt32 &b, UInt16 shift) noexcept
constexpr UInt32 &	operator<<= (UInt32 &b, UInt32 shift) noexcept
constexpr UInt32 &	operator<<= (UInt32 &b, UInt8 shift) noexcept
constexpr UInt64 &	operator<<= (UInt64 &b, std::uint64_t shift) noexcept
constexpr UInt64 &	operator<<= (UInt64 &b, UInt16 shift) noexcept
constexpr UInt64 &	operator<<= (UInt64 &b, UInt32 shift) noexcept
constexpr UInt64 &	operator<<= (UInt64 &b, UInt64 shift) noexcept
constexpr UInt64 &	operator<<= (UInt64 &b, UInt8 shift) noexcept
constexpr UInt8 &	operator<<= (UInt8 &b, std::uint8_t shift) noexcept
constexpr UInt8 &	operator<<= (UInt8 &b, UInt8 shift) noexcept
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator<= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator<= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator<= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator<= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator<= (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator<= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator<= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator<= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator<= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator<= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator<= (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T >
constexpr bool	operator<= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator<= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator<= (optional< T > const &lhs, optional< U > const &rhs)
template<typename T >
constexpr bool	operator<= (optional< T > const &opt, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator<= (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator<= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator<= (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator<= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator<= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator<= (std::nullopt_t, optional< T > const &) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator<= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
constexpr bool	operator<= (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator<= (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr bool	operator<= (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr bool	operator<= (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr bool	operator<= (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator<= (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr bool	operator<= (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename T , typename U >
constexpr bool	operator<= (T const &value, optional< U > const &opt)
template<typename CharT , size_t Capacity>
constexpr bool	operator<= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator<= (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator<= (UInt16 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator<= (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr bool	operator<= (UInt32 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator<= (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator<= (UInt8 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator<= (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator<= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator<= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs<= *rhs))
template<typename T , typename U , size_t N>
constexpr bool	operator== (array< T, N > const &lhs, array< U, N > const &rhs)
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator== (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename Key , typename Value >
constexpr bool	operator== (bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key , typename Value >
constexpr bool	operator== (bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key >
constexpr bool	operator== (bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename Key >
constexpr bool	operator== (bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator== (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename Key , typename Value >
constexpr bool	operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key , typename Value >
constexpr bool	operator== (const_bounded_hash_map_iterator< Key, Value > const &lhs, const_bounded_hash_map_iterator< Key, Value > const &rhs)
template<typename Key >
constexpr bool	operator== (const_bounded_hash_set_iterator< Key > const &lhs, bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename Key >
constexpr bool	operator== (const_bounded_hash_set_iterator< Key > const &lhs, const_bounded_hash_set_iterator< Key > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator== (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator== (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator== (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator== (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator== (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator== (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator== (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator== (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator== (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator== (indexed_iterator< T > const &, indexed_iterator< U > const &) noexcept
template<typename T >
constexpr bool	operator== (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator== (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
constexpr bool	operator== (node_id_t const &lhs, node_id_t const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator== (optional< T > const &lhs, optional< U > const &rhs)
template<typename T >
constexpr bool	operator== (optional< T > const &opt, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator== (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator== (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator== (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename CharT >
constexpr bool	operator== (repeat_n_char_iterator< CharT > const &lhs, repeat_n_char_iterator< CharT > const &rhs) noexcept
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator== (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename Iterator >
constexpr bool	operator== (splitter_range_t< Iterator > const &lhs, splitter_range_t< Iterator > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator== (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator== (std::nullopt_t, optional< T > const &opt) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator== (std::nullptr_t, copiable_unique_ptr< T1, D1 > const &rhs) noexcept
constexpr bool	operator== (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator== (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr bool	operator== (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr bool	operator== (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr bool	operator== (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator== (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr bool	operator== (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename CharT >
constexpr bool	operator== (string_split_iterator< CharT > const &lhs, string_split_iterator< CharT > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator== (T const &value, optional< U > const &opt)
template<typename CharT , size_t Capacity>
constexpr bool	operator== (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator== (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator== (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr bool	operator== (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator== (UInt64 lhs, UInt16 rhs) noexcept
constexpr bool	operator== (UInt64 lhs, UInt32 rhs) noexcept
constexpr bool	operator== (UInt64 lhs, UInt8 rhs) noexcept
constexpr bool	operator== (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator== (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_equality< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator== (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs== *rhs))
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator> (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator> (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator> (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator> (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator> (daw::basic_bounded_string< CharT, Capacity > const &lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator> (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator> (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator> (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator> (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator> (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator> (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T >
constexpr bool	operator> (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator> (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator> (optional< T > const &lhs, optional< U > const &rhs)
template<typename T >
constexpr bool	operator> (optional< T > const &opt, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator> (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator> (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator> (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator> (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator> (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator> (std::nullopt_t, optional< T > const &) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator> (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
constexpr bool	operator> (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator> (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr bool	operator> (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr bool	operator> (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator> (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr bool	operator> (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename T , typename U >
constexpr bool	operator> (T const &value, optional< U > const &opt)
template<typename CharT , size_t Capacity>
constexpr bool	operator> (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator> (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator> (UInt16 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator> (UInt32 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator> (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator> (UInt8 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator> (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator> (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator> (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs > *rhs))
template<typename CharT , size_t CapacityL, size_t CapacityR>
constexpr bool	operator>= (basic_bounded_string< CharT, CapacityL > const &lhs, basic_bounded_string< CharT, CapacityR > const &rhs) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator>= (CharT const (&lhs)[N], daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator>= (const T &value, const optional< U > &opt)
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator>= (copiable_unique_ptr< T1, D1 > const &lhs, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator>= (copiable_unique_ptr< T1, D1 > const &lhs, std::nullptr_t) noexcept
template<typename CharT , size_t Capacity, size_t N>
constexpr bool	operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, CharT const (&rhs)[N]) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, daw::sv1::basic_string_view< CharT > rhs) noexcept
template<typename CharT , size_t Capacity>
bool	operator>= (daw::basic_bounded_string< CharT, Capacity > const &lhs, std::basic_string< CharT > const &rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator>= (daw::basic_bounded_string< CharT, Capacity > lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer rhs) noexcept
template<typename Lhs , typename Rhs >
DAW_ATTRIB_INLINE constexpr bool	operator>= (daw::not_null< Lhs > const &lhs, daw::not_null< Rhs > const &rhs) noexcept
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator>= (daw::not_null< Pointer > const &lhs, Pointer const &rhs) noexcept
template<typename T >
bool	operator>= (daw::optional_poly< T > const &lhs, daw::optional_poly< T > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator>= (daw::sv1::basic_string_view< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T , typename U >
bool	operator>= (hash_table_item_iterator< T > const &lhs, hash_table_item_iterator< U > const &rhs)
template<typename T , typename U >
bool	operator>= (heap_value< T > const &lhs, heap_value< U > const &rhs)
template<typename T >
constexpr bool	operator>= (indexed_iterator< T > const &lhs, indexed_iterator< T > const &rhs) noexcept
template<typename T , typename U >
constexpr bool	operator>= (natural_t< T > const &lhs, natural_t< U > const &rhs) noexcept
template<typename T >
constexpr bool	operator>= (optional< T > const &, std::nullopt_t) noexcept
template<typename T , typename U >
constexpr bool	operator>= (optional< T > const &lhs, optional< U > const &rhs)
template<typename T , typename U >
constexpr bool	operator>= (optional< T > const &opt, U const &value)
template<typename Pointer >
DAW_ATTRIB_INLINE constexpr bool	operator>= (Pointer const &lhs, daw::not_null< Pointer > const &rhs) noexcept
template<typename T >
bool	operator>= (Reference< T > const &lhs, Reference< T > const &rhs)
template<typename Iterator1 , typename Iterator2 >
constexpr bool	operator>= (reverse_iterator< Iterator1 > const &lhs, reverse_iterator< Iterator2 > const &rhs)
template<typename CharT , size_t Capacity>
constexpr bool	operator>= (std::basic_string< CharT > const &lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
template<typename T >
constexpr bool	operator>= (std::nullopt_t, optional< T > const &opt) noexcept
template<typename T1 , typename D1 , typename T2 , typename D2 >
constexpr bool	operator>= (std::nullptr_t, copiable_unique_ptr< T2, D2 > const &rhs) noexcept
constexpr bool	operator>= (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr bool	operator>= (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr bool	operator>= (std::uint64_t lhs, UInt16 rhs) noexcept
constexpr bool	operator>= (std::uint64_t lhs, UInt32 rhs) noexcept
constexpr bool	operator>= (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr bool	operator>= (std::uint64_t lhs, UInt8 rhs) noexcept
constexpr bool	operator>= (std::uint8_t lhs, UInt8 rhs) noexcept
template<typename CharT , size_t Capacity>
constexpr bool	operator>= (typename daw::basic_bounded_string< CharT, Capacity >::const_pointer lhs, daw::basic_bounded_string< CharT, Capacity > const &rhs) noexcept
constexpr bool	operator>= (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr bool	operator>= (UInt16 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator>= (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr bool	operator>= (UInt32 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator>= (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator>= (UInt8 lhs, std::uint64_t rhs) noexcept
constexpr bool	operator>= (UInt8 lhs, std::uint8_t rhs) noexcept
template<typename T , typename D0 , typename D1 = D0>
constexpr bool	operator>= (unique_ptr< T, D0 > const &lhs, unique_ptr< T, D1 > const &rhs) noexcept
template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater_equal< T, U >, std::nullptr_t > = nullptr>
constexpr bool	operator>= (value_ptr< T > const &lhs, value_ptr< U > const &rhs) noexcept(noexcept(*lhs >= *rhs))
constexpr std::uint16_t	operator>> (std::uint16_t b, UInt16 shift) noexcept
constexpr std::uint32_t	operator>> (std::uint32_t b, UInt16 shift) noexcept
constexpr std::uint32_t	operator>> (std::uint32_t b, UInt32 shift) noexcept
constexpr std::uint32_t	operator>> (std::uint32_t b, UInt8 shift) noexcept
constexpr std::uint64_t	operator>> (std::uint64_t b, UInt16 shift) noexcept
constexpr std::uint64_t	operator>> (std::uint64_t b, UInt32 shift) noexcept
constexpr std::uint64_t	operator>> (std::uint64_t b, UInt64 shift) noexcept
constexpr std::uint64_t	operator>> (std::uint64_t b, UInt8 shift) noexcept
constexpr std::uint8_t	operator>> (std::uint8_t b, UInt8 shift) noexcept
constexpr UInt16	operator>> (UInt16 b, std::uint16_t shift) noexcept
constexpr UInt16	operator>> (UInt16 b, UInt16 shift) noexcept
constexpr UInt32	operator>> (UInt32 b, std::uint32_t shift) noexcept
constexpr UInt32	operator>> (UInt32 b, UInt16 shift) noexcept
constexpr UInt32	operator>> (UInt32 b, UInt32 shift) noexcept
constexpr UInt32	operator>> (UInt32 b, UInt8 shift) noexcept
constexpr UInt64	operator>> (UInt64 b, std::uint64_t shift) noexcept
constexpr UInt64	operator>> (UInt64 b, UInt16 shift) noexcept
constexpr UInt64	operator>> (UInt64 b, UInt32 shift) noexcept
constexpr UInt64	operator>> (UInt64 b, UInt64 shift) noexcept
constexpr UInt64	operator>> (UInt64 b, UInt8 shift) noexcept
constexpr UInt8	operator>> (UInt8 b, std::uint8_t shift) noexcept
constexpr UInt8	operator>> (UInt8 b, UInt8 shift) noexcept
constexpr UInt16 &	operator>>= (UInt16 &b, std::uint16_t shift) noexcept
constexpr UInt16 &	operator>>= (UInt16 &b, UInt16 shift) noexcept
constexpr UInt16 &	operator>>= (UInt16 &b, UInt8 shift) noexcept
constexpr UInt32 &	operator>>= (UInt32 &b, std::uint32_t shift) noexcept
constexpr UInt32 &	operator>>= (UInt32 &b, UInt16 shift) noexcept
constexpr UInt32 &	operator>>= (UInt32 &b, UInt32 shift) noexcept
constexpr UInt32 &	operator>>= (UInt32 &b, UInt8 shift) noexcept
constexpr UInt64 &	operator>>= (UInt64 &b, std::uint64_t shift) noexcept
constexpr UInt64 &	operator>>= (UInt64 &b, UInt16 shift) noexcept
constexpr UInt64 &	operator>>= (UInt64 &b, UInt32 shift) noexcept
constexpr UInt64 &	operator>>= (UInt64 &b, UInt64 shift) noexcept
constexpr UInt64 &	operator>>= (UInt64 &b, UInt8 shift) noexcept
constexpr UInt8 &	operator>>= (UInt8 &b, std::uint8_t shift) noexcept
constexpr UInt8 &	operator>>= (UInt8 &b, UInt8 shift) noexcept
constexpr UInt16	operator^ (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator^ (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt64	operator^ (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator^ (std::uint8_t lhs, UInt8 rhs) noexcept
constexpr UInt16	operator^ (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator^ (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator^ (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator^ (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator^ (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator^ (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator^ (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator^ (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator^ (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator^ (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator^ (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator^ (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator^ (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator^ (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator^ (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator^ (UInt8 lhs, std::uint8_t rhs) noexcept
constexpr UInt32	operator^ (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator^ (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator^ (UInt8 lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator^= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator^= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator^= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator^= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator^= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator^= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator^= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator^= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator^= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator^= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator^= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator^= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator^= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator^= (UInt8 &lhs, UInt8 rhs) noexcept
constexpr UInt16	operator| (std::uint16_t lhs, UInt16 rhs) noexcept
constexpr UInt32	operator| (std::uint32_t lhs, UInt32 rhs) noexcept
constexpr UInt64	operator| (std::uint64_t lhs, UInt64 rhs) noexcept
constexpr UInt8	operator| (std::uint8_t lhs, UInt8 rhs) noexcept
constexpr UInt16	operator| (UInt16 lhs, std::uint16_t rhs) noexcept
constexpr UInt16	operator| (UInt16 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator| (UInt16 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator| (UInt16 lhs, UInt64 rhs) noexcept
constexpr UInt16	operator| (UInt16 lhs, UInt8 rhs) noexcept
constexpr UInt32	operator| (UInt32 lhs, std::uint32_t rhs) noexcept
constexpr UInt32	operator| (UInt32 lhs, UInt16 rhs) noexcept
constexpr UInt32	operator| (UInt32 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator| (UInt32 lhs, UInt64 rhs) noexcept
constexpr UInt32	operator| (UInt32 lhs, UInt8 rhs) noexcept
constexpr UInt64	operator| (UInt64 lhs, std::uint64_t rhs) noexcept
constexpr UInt64	operator| (UInt64 lhs, UInt16 rhs) noexcept
constexpr UInt64	operator| (UInt64 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator| (UInt64 lhs, UInt64 rhs) noexcept
constexpr UInt64	operator| (UInt64 lhs, UInt8 rhs) noexcept
constexpr UInt8	operator| (UInt8 lhs, std::uint8_t rhs) noexcept
constexpr UInt32	operator| (UInt8 lhs, UInt32 rhs) noexcept
constexpr UInt64	operator| (UInt8 lhs, UInt64 rhs) noexcept
constexpr UInt8	operator| (UInt8 lhs, UInt8 rhs) noexcept
constexpr UInt16 &	operator|= (UInt16 &lhs, std::uint16_t rhs) noexcept
constexpr UInt16 &	operator|= (UInt16 &lhs, UInt16 rhs) noexcept
constexpr UInt16 &	operator|= (UInt16 &lhs, UInt8 rhs) noexcept
constexpr UInt32 &	operator|= (UInt32 &lhs, std::uint32_t rhs) noexcept
constexpr UInt32 &	operator|= (UInt32 &lhs, UInt16 rhs) noexcept
constexpr UInt32 &	operator|= (UInt32 &lhs, UInt32 rhs) noexcept
constexpr UInt32 &	operator|= (UInt32 &lhs, UInt8 rhs) noexcept
constexpr UInt64 &	operator|= (UInt64 &lhs, std::uint64_t rhs) noexcept
constexpr UInt64 &	operator|= (UInt64 &lhs, UInt16 rhs) noexcept
constexpr UInt64 &	operator|= (UInt64 &lhs, UInt32 rhs) noexcept
constexpr UInt64 &	operator|= (UInt64 &lhs, UInt64 rhs) noexcept
constexpr UInt64 &	operator|= (UInt64 &lhs, UInt8 rhs) noexcept
constexpr UInt8 &	operator|= (UInt8 &lhs, std::uint8_t rhs) noexcept
constexpr UInt8 &	operator|= (UInt8 &lhs, UInt8 rhs) noexcept
constexpr UInt16	operator~ (UInt16 value)
constexpr UInt32	operator~ (UInt32 value)
constexpr UInt64	operator~ (UInt64 value)
constexpr UInt8	operator~ (UInt8 value)
constexpr auto	or_all () noexcept
template<typename Value >
constexpr Value	or_all (Value value) noexcept
template<typename Value , typename... T>
constexpr decltype(auto)	or_all (Value value, T... values) noexcept
template<typename... Funcs>
	overload (Funcs &&...) -> overload< conditional_t< std::is_class_v< daw::remove_cvref_t< Funcs > >, daw::remove_cvref_t< Funcs >, Funcs >... >
template<typename Function , typename... Args>
constexpr void	pack_apply (std::size_t N, Function &&func, Args &&...args)
template<size_t N, std::size_t pos = 0, typename Arg , typename... Args>
constexpr decltype(auto)	pack_get (Arg &&arg, Args &&...args) noexcept
template<typename T , typename BitStream >
auto	pop_value (BitStream &bs)
template<typename T , typename BitStream >
auto	pop_value (BitStream &bs, size_t bits_needed)
template<typename Iterator >
constexpr Iterator	prev (Iterator it, ptrdiff_t n=1) noexcept
	Move iterator backward n steps, if n > 0, only defined for types that are Bidirectional.
template<typename... Args>
DAW_ATTRIB_NOINLINE void	print (FILE *fout, std::format_string< Args... > fmt, Args &&...args)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	print (std::format_string< Args... > fmt, Args &&...args)
template<typename... Args>
std::ostream &	print (std::ostream &os, std::format_string< Args... > fmt, Args &&...args)
DAW_ATTRIB_INLINE void	println ()
template<typename... Args>
DAW_ATTRIB_NOINLINE void	println (FILE *f, std::format_string< Args... > fmt, Args &&...args)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	println (std::format_string< Args... > fmt, Args &&...args)
template<typename... Args>
std::ostream &	println (std::ostream &os, std::format_string< Args... > fmt, Args &&...args)
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	quick_sort (RandomIterator f, RandomIterator l, Compare cmp=Compare{ })
template<typename IntType >
IntType	randint ()
template<typename IntType >
IntType	randint (IntType a, IntType b)
template<typename IntType , typename ItValueType = IntType, typename ForwardIterator >
void	random_fill (ForwardIterator first, ForwardIterator const last, IntType a, IntType b)
template<typename CharT = char>
DAW_ATTRIB_NOINLINE std::optional< std::basic_string< CharT > >	read_file (std::string const &path) noexcept
std::string	read_file (std::string const &path, terminate_on_read_file_error_t) noexcept
template<typename T , typename = void>
auto	ref (T const &value)
template<typename T >
auto	ref (T const *value)
template<typename T = char>
constexpr auto	repeat_n_char_end () noexcept
template<typename CharT >
	repeat_n_char_iterator (size_t, CharT) -> repeat_n_char_iterator< CharT >
void	reseed ()
void	reseed (std::default_random_engine::result_type value)
template<typename T >
void	return_buffer (T *ptr) noexcept
template<typename Iterator >
	reverse_iterator (Iterator) -> reverse_iterator< Iterator >
template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void	reverse_topological_sorted_walk (daw::graph_t< T > &known_deps, Func visitor, Compare &&comp=Compare{ })
template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>
void	reverse_topological_sorted_walk (daw::graph_t< T > const &known_deps, Func visitor, Compare &&comp=Compare{ })
template<typename T >
	ring_adaptor (T const &) -> ring_adaptor< T >
template<unsigned bits>
constexpr UInt16	rotate_left (UInt16 value)
constexpr UInt16	rotate_left (UInt16 value, unsigned bits)
template<unsigned bits>
constexpr UInt32	rotate_left (UInt32 value)
constexpr UInt32	rotate_left (UInt32 value, unsigned bits)
template<unsigned bits>
constexpr UInt64	rotate_left (UInt64 value)
constexpr UInt64	rotate_left (UInt64 value, unsigned bits)
template<unsigned bits>
constexpr UInt8	rotate_left (UInt8 value)
constexpr UInt8	rotate_left (UInt8 value, unsigned bits)
template<unsigned bits>
constexpr UInt16	rotate_right (UInt16 value)
constexpr UInt16	rotate_right (UInt16 value, unsigned bits)
template<unsigned bits>
constexpr UInt32	rotate_right (UInt32 value)
constexpr UInt32	rotate_right (UInt32 value, unsigned bits)
template<unsigned bits>
constexpr UInt64	rotate_right (UInt64 value)
constexpr UInt64	rotate_right (UInt64 value, unsigned bits)
template<unsigned bits>
constexpr UInt8	rotate_right (UInt8 value)
constexpr UInt8	rotate_right (UInt8 value, unsigned bits)
template<typename T >
auto	RunIfValid (std::weak_ptr< T > w_ptr)
template<typename Container , typename Iterator , typename Distance >
constexpr void	safe_advance (Container &container, Iterator &it, Distance distance) noexcept
	Advance Iterator within the bounds of container.
template<typename Container , typename Iterator , typename Distance >
constexpr void	safe_advance (Container const &container, Iterator &it, Distance distance) noexcept
	Advance Iterator within the bounds of container.
template<typename Iterator , typename Distance = size_t>
constexpr Iterator	safe_next (Iterator it, Iterator const last, Distance n=1U) noexcept(noexcept(daw::next(it, static_cast< std::ptrdiff_t >(n))))
	Advance iterator n steps forward but do not go past last. Undefined if it > last.
template<typename Iterator , typename Distance >
constexpr Iterator	safe_prev (Iterator it, Iterator first, Distance n=1) noexcept(noexcept(daw::prev(it, static_cast< std::ptrdiff_t >(n))))
	Advance iterator n steps backward but do not go past first. Undefined if it < first.
template<unsigned N>
constexpr void	set_bit (UInt16 &value, bool state)
template<unsigned N>
constexpr void	set_bit (UInt32 &value, bool state)
template<unsigned N>
constexpr void	set_bit (UInt64 &value, bool state)
template<unsigned N>
constexpr void	set_bit (UInt8 &value, bool state)
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer	set_bits (Integer i, Bit b, Bits... bs) noexcept
	set bits at positions specified by b,bs...
template<typename Func >
DAW_ATTRIB_NOINLINE void	show_benchmark (size_t data_size_bytes, std::string const &title, Func &&func, size_t data_prec=1, size_t time_prec=0, size_t item_count=1)
template<typename RandomIterator >
void	shuffle (RandomIterator first, RandomIterator last)
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
DAW_ATTRIB_INLINE constexpr bool	signbit (T t)
template<typename T , typename... Ts>
	simple_array (T &&, Ts &&...) -> simple_array< T, sizeof...(Ts)+1 >
template<typename Byte >
constexpr uint64_t	siphash24 (Byte const *first, size_t sz, Byte const *const key)
template<typename Container >
constexpr auto	size (Container const &c) noexcept(noexcept(c.size())) -> decltype(c.size())
template<typename BitStream >
void	skip_bits (BitStream &bs, size_t bits_needed)
template<typename BitStream >
void	skip_bytes (BitStream &bs, size_t bytes_needed)
template<typename BitStream , typename TestValue >
void	skip_until (BitStream &bs, TestValue const &v)
template<typename BitStream , typename TestValue >
void	skip_until (BitStream &bs, TestValue const &v, size_t bit_count)
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort (RandomIterator first, RandomIterator last, Compare &&comp=Compare{ }) noexcept(sort_n_details::is_nothrow_sortable_v< RandomIterator, Compare >)
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_16 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_3 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_32 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_4 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_5 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_6 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_7 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename RandomIterator , typename Compare = std::less<>>
constexpr void	sort_8 (RandomIterator first, Compare &&comp=Compare{ }) noexcept
template<typename ForwardIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator	sort_to (ForwardIterator first_in, ForwardIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ })
template<typename InputIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>
constexpr RandomOutputIterator	sort_to (InputIterator first_in, InputIterator last_in, RandomOutputIterator first_out, Compare &&comp=Compare{ })
template<typename Container >
	span (Container &) -> span< std::remove_reference_t< decltype(*std::data(std::declval< Container >()))> >
template<typename Container >
	span (Container const &) -> span< DAW_TYPEOF(*std::data(std::declval< Container >())) const >
template<typename T >
	span (T *, size_t) -> span< T >
template<typename T >
	span (T *, T *) -> span< T >
template<typename T >
	span (T *, T const *) -> span< T >
template<typename T , size_t N>
	span (T const (&)[N]) -> span< T const >
template<typename T >
	span (T const *, size_t) -> span< T const >
template<typename T >
	span (T const *, T *) -> span< T const >
template<typename T >
	span (T const *, T const *) -> span< T const >
template<typename T , size_t N>
	span (T(&)[N]) -> span< T >
template<typename CharT , size_t Capacity, size_t N>
auto	split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const (&delemiter)[N])=delete
template<typename CharT , size_t Capacity>
auto	split (daw::basic_bounded_string< CharT, Capacity > &&str, CharT const delemiter)=delete
template<typename CharT , size_t Capacity, size_t N>
auto	split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const (&delemiter)[N])
template<typename CharT , size_t Capacity>
auto	split (daw::basic_bounded_string< CharT, Capacity > const &str, CharT const delemiter)
template<typename CharT , size_t N, typename UnaryPredicate >
auto	split (daw::basic_bounded_string< CharT, N > &&str, UnaryPredicate pred)=delete
template<typename CharT , size_t N, typename UnaryPredicate >
auto	split (daw::basic_bounded_string< CharT, N > const &str, UnaryPredicate pred)
template<std::size_t StartN, std::size_t EndN, typename... Args, std::enable_if_t<(sizeof...(Args) >=EndN), std::nullptr_t > = nullptr>
constexpr auto	split_args (std::tuple< Args... > args)
template<std::size_t StartN, typename... Args, std::size_t... Is, std::enable_if_t<(sizeof...(Args) >=(sizeof...(Is)+StartN)), std::nullptr_t > = nullptr>
constexpr auto	split_args_impl (std::tuple< Args... > &&args, std::index_sequence< Is... >)
template<typename CharT , typename Bounds = daw::sv1::default_string_view_bounds_type, size_t N, size_t M>
constexpr string_split_range< CharT >	split_string (CharT const (&str)[N], CharT const (&delemiter)[M]) noexcept
template<typename CharT >
constexpr string_split_range< CharT >	split_string (daw::sv1::basic_string_view< CharT > str, daw::sv1::basic_string_view< CharT > delemiter) noexcept
template<typename CharT , typename Bounds , std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT >	split_string (daw::sv1::basic_string_view< CharT, Bounds, Ex > str, CharT const (&delemiter)[N]) noexcept
template<typename CharT , daw::sv2::string_view_bounds_type Bounds, std::ptrdiff_t Ex, size_t N>
constexpr string_split_range< CharT >	split_string (daw::sv2::basic_string_view< CharT, Bounds > str, CharT const (&delemiter)[N]) noexcept
template<typename CharT >
string_split_range< CharT >	split_string (std::basic_string< CharT > const &str, daw::sv1::basic_string_view< CharT > delemiter) noexcept
template<typename CharT >
string_split_range< CharT >	split_string (std::basic_string< CharT > const &str, std::basic_string< CharT > &delemiter) noexcept
template<typename... Strings>
std::string	string_concat (std::string arg, Strings &&...strings)
template<typename CharT >
	string_split_iterator (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_iterator< CharT >
template<typename CharT >
	string_split_range (daw::sv1::basic_string_view< CharT >, daw::sv1::basic_string_view< CharT >) -> string_split_range< CharT >
template<typename CharT , size_t N>
constexpr void	swap (basic_bounded_string< CharT, N > &lhs, basic_bounded_string< CharT, N > &rhs) noexcept
template<typename T , size_t N>
constexpr void	swap (carray< T, N > &lhs, carray< T, N > &rhs) noexcept(std::is_nothrow_move_assignable_v< T >)
template<class T1 , class T2 >
constexpr void	swap (compressed_pair< T1, T2 > &x, compressed_pair< T1, T2 > &y) noexcept(std::is_nothrow_swappable_v< T1 > and std::is_nothrow_swappable_v< T2 >)
template<typename T , typename Deleter >
constexpr void	swap (copiable_unique_ptr< T, Deleter > &lhs, copiable_unique_ptr< T, Deleter > &rhs) noexcept
template<typename... Args>
void	swap (CString< Args... > &lhs, CString< Args... > &rhs) noexcept
template<typename T >
constexpr void	swap (daw::heap_array< T > &lhs, daw::heap_array< T > &rhs) noexcept
template<typename T >
void	swap (daw::optional_poly< T > &lhs, daw::optional_poly< T > &rhs) noexcept
template<typename T >
void	swap (hash_table< T > &lhs, hash_table< T > &rhs) noexcept
template<typename T >
void	swap (hash_table_item_iterator< T > &lhs, hash_table_item_iterator< T > &rhs) noexcept
template<typename T >
void	swap (heap_value< T > &lhs, heap_value< T > &rhs) noexcept
template<typename T , typename D >
constexpr void	swap (rc_ptr< T, D > &lhs, rc_ptr< T, D > &rhs)
template<class T , class Allocator >
constexpr void	swap (split_buffer< T, Allocator > &x, split_buffer< T, Allocator > &y) noexcept(noexcept(x.swap(y)))
template<typename T >
constexpr void	swap (value_ptr< T > &lhs, value_ptr< T > &rhs) noexcept(noexcept(lhs.swap(rhs)))
template<typename T , typename Allocator >
constexpr void	swap (vector< T, Allocator > &x, vector< T, Allocator > &y) noexcept(noexcept(x.swap(y)))
template<typename ForwardIterator1 , typename ForwardIterator2 >
constexpr ForwardIterator2	swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2) noexcept(noexcept(daw::iter_swap(first1, first2)))
template<typename T , std::enable_if_t< std::is_default_constructible_v< T >, std::nullptr_t > = nullptr>
constexpr T	take (T &value) noexcept(std::is_nothrow_move_constructible_v< T > and std::is_nothrow_default_constructible_v< T >)
template<typename... Ts>
constexpr tuple< Ts &... >	tie (Ts &...ts) noexcept
template<typename T >
constexpr T *	to_address (T *p) noexcept
template<typename T >
constexpr auto	to_address (T const &p) noexcept
template<typename T , std::size_t N>
constexpr std::array< std::remove_cv_t< T >, N >	to_array (T(&a)[N])
template<typename To , typename From >
auto	to_array_of (From &&from) noexcept
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T	to_big_endian (T value) noexcept
template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T	to_little_endian (T value) noexcept
template<endian SourceEndian, typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>
constexpr T	to_native_endian (T value) noexcept
template<typename CharT , typename OutputIterator , typename Integer , typename Traits = daw::impl::char_traits<CharT>, std::enable_if_t< can_to_os_string_int_v< daw::remove_cvref_t< Integer > >, std::nullptr_t > = nullptr>
constexpr OutputIterator	to_os_string_int (OutputIterator it, Integer value)
template<typename Iterator >
auto	to_reference_vector (Iterator first, Iterator last)
template<typename Char >
std::string	to_string (CString< Char > const &str)
template<size_t BitWidth>
std::string	to_string (static_bitset< BitWidth > const &bs)
template<typename Number >
constexpr UInt16	to_uint16 (Number num)
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt16	to_uint16_buffer (CharT const *ptr) noexcept
template<typename Number >
constexpr UInt32	to_uint32 (Number num)
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt32	to_uint32_buffer (CharT const *ptr) noexcept
template<typename Number >
constexpr UInt64	to_uint64 (Number num)
template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>
constexpr UInt64	to_uint64_buffer (CharT const *ptr) noexcept
template<typename Number >
constexpr UInt8	to_uint8 (Number num)
template<typename Enum , std::enable_if_t< std::is_enum_v< Enum >, std::nullptr_t > = nullptr>
constexpr auto	to_underlying (Enum e)
template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void	topological_sorted_walk (daw::graph_t< T > &graph, Function &&func, Compare comp=Compare{ })
template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>
void	topological_sorted_walk (daw::graph_t< T > const &graph, Function &&func, Compare comp=Compare{ })
template<typename Map , typename Key >
constexpr auto	try_get (Map &container, Key &&k)
template<typename Map , typename Key >
constexpr auto	try_get (Map const &container, Key &&k)
template<typename... Ts>
	tuple (Ts...) -> tuple< Ts... >
template<typename... Ts>
	tuple2 (Ts...) -> tuple2< Ts... >
constexpr tuple2	tuple2_cat ()
template<typename T0 , typename T1 , typename... Tps>
constexpr auto	tuple2_cat (T0 &&t0, T1 &&t1, Tps &&...tps)
template<typename Tuple >
constexpr tuple2	tuple2_cat (Tuple &&tp)
template<typename Integer , typename Bit , typename... Bits>
constexpr Integer	unset_bits (Integer i, Bit b, Bits... bs) noexcept
	set bits at positions specified by b,bs...
template<typename To >
constexpr uint16_t	value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint16_t)>) noexcept
template<typename To >
constexpr uint32_t	value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint32_t)>) noexcept
template<typename To >
constexpr uint64_t	value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint64_t)>) noexcept
template<typename To >
constexpr uint8_t	value_from_chars (unsigned char const *ptr, std::integral_constant< size_t, sizeof(uint8_t)>) noexcept
template<typename T >
constexpr auto	value_is (T &&value) -> daw::utility_details::value_is_utility_details< std::remove_reference_t< decltype(value)> >
template<typename... Args, typename Stream >
decltype(auto)	values_from_stream (Stream &&s, daw::string_view delemiter)
	Extract specified argument types from a stream of character data.
template<typename... Args, typename Stream , typename Splitter , std::enable_if_t<(not parse_to_impl::has_str_member_v< Stream > and std::is_invocable_v< Splitter, daw::string_view >), std::nullptr_t > = nullptr>
decltype(auto)	values_from_stream (Stream &&stream, Splitter &&splitter)
	Extract specified argument types from a stream of character data.
template<typename T , typename... Args>
constexpr T	variant_cast (std::variant< Args... > &&var)
template<typename T , typename... Args>
constexpr T	variant_cast (std::variant< Args... > &var)
template<typename T , typename... Args>
constexpr T	variant_cast (std::variant< Args... > const &var)
template<input_iterator InputIterator>
	vector (InputIterator, InputIterator) -> vector< iter_value_type< InputIterator >, std::allocator< iter_value_type< InputIterator > > >
template<input_iterator InputIterator, Allocators Alloc>
	vector (InputIterator, InputIterator, Alloc) -> vector< iter_value_type< InputIterator >, Alloc >
template<typename T , std::size_t N>
	Vector (T const (&)[N]) -> Vector< T >
template<typename BidirectionalIterator >
	view (BidirectionalIterator, BidirectionalIterator) -> view< BidirectionalIterator >
template<typename Variant , typename... Visitors>
constexpr decltype(auto)	visit (Variant &&var, Visitors &&...visitors)
template<typename Result , typename Variant , typename... Visitors>
constexpr Result	visit (Variant &&var, Visitors &&...visitors)
template<typename Variant , typename... Visitors>
constexpr decltype(auto)	visit_nt (Variant &&var, Visitors &&...visitors)
template<typename Result , typename Variant , typename... Visitors>
constexpr Result	visit_nt (Variant &&var, Visitors &&...visitors)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	vprint (FILE *fout, std::string_view fmt, Args &&...args)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	vprint (std::string_view fmt, Args &&...args)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	vprintln (FILE *f, std::string fmt, Args &&...args)
template<typename... Args>
DAW_ATTRIB_NOINLINE void	vprintln (std::string fmt, Args &&...args)
template<typename... Containers>
	zip_container (Containers &&...) -> zip_container< Containers... >
template<typename... Iterators>
	zip_iterator (Iterators...) -> zip_iterator< Iterators... >

Variables
template<bool... values>
constexpr bool	all_true_v = ( values and ... )
template<typename... Ts>
constexpr bool	always_false_v = always_false<Ts...>::value
template<auto needle, auto... needles>
static constexpr any_of_t< decltype(needle), needle, needles... >	any_of { }
	A predicate value used in the find based routine to return true when the element is one of the specified characters.
template<bool... values>
constexpr bool	any_true_v = ( values or ... )
template<typename T >
constexpr std::size_t	bit_count_v = sizeof( T ) * CHAR_BIT
template<typename T >
constexpr std::size_t const	bsizeof
template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool	can_call_v
template<DAW_CXEVAL_FTYPE F>
constexpr bool	can_constant_evaluate_v
template<typename T , typename... Args>
constexpr bool	can_construct_a_v
template<typename T , typename... Args>
constexpr bool	can_potentially_constant_construct_v
template<typename Integer >
constexpr bool	can_to_os_string_int_v
template<typename... Ts>
constexpr bool	conjunction_v
template<decltype(auto) Value>
constexpr auto	constant_v = constant<Value>{ }
template<typename T >
constexpr construct_a_t< T >	construct_a = construct_a_t<T>{ }
template<typename T = void>
constexpr construct_emplace_t< T >	construct_emplace { }
constexpr construct_for_overwrite_t	construct_for_overwrite { }
static constinit thread_local daw::function_ref< void()>	contract_failure_handler = default_contract_failure
template<typename... >
constexpr bool	deduced_false_v = false
template<typename... >
constexpr bool	dependent_false_v = false
template<typename T >
constexpr daw::string_view	describe_v = impl::describe_impl<T>( )
template<typename T >
constexpr auto	digits = numeric_limits<T>::digits
template<typename T >
constexpr auto	digits10 = numeric_limits<T>::digits10
constexpr auto	discard = discard_t{ }
template<typename... Ts>
constexpr bool	disjunction_v
constexpr auto	do_resize_and_overwrite = do_resize_and_overwrite_t{ }
constexpr auto	dont_clip_to_bounds = dont_clip_to_bounds_t{ }
constexpr auto	DynamicExtent = max_value<std::size_t>
constexpr bitset_impl::fmt_binary_t const	fmt_binary { }
constexpr bitset_impl::fmt_decimal_t const	fmt_decimal { }
constexpr bitset_impl::fmt_hex_t const	fmt_hex { }
template<typename Container >
constexpr bool	has_kv_mapping_v
	Specifies that Container has type alias members key_type and mapped_type.
template<typename T >
constexpr bool	has_slow_distance_v
template<std::size_t N>
constexpr index_constant< N >	index_constant_v = index_constant<N>{ }
template<auto Needle, auto... Haystack>
constexpr bool	is_any_of_v = ( ( Needle == Haystack ) or ... )
template<typename T >
constexpr bool	is_arithmetic_v
constexpr auto	is_ascii_alpha = is_ascii_alpha_t{ }
constexpr auto	is_ascii_alphanum = is_ascii_alphanum_t{ }
constexpr auto	is_ascii_digit = is_ascii_digit_t{ }
constexpr auto	is_ascii_printable = is_ascii_printable_t{ }
template<typename T >
constexpr bool	is_bounded_graph_node_v = false
template<typename T , size_t MaxVerticesPerNode, typename Hash >
constexpr bool	is_bounded_graph_node_v< bounded_graph_node_t< T, MaxVerticesPerNode, Hash > >
template<typename T , size_t MaxVerticesPerNode, typename Hash >
constexpr bool	is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >
template<typename T >
constexpr bool	is_complete_type_v
template<typename T >
constexpr bool const	is_daw_span_v = is_daw_span_t<T>::value
template<typename T >
constexpr bool	is_deduced_type_v = false
template<>
constexpr bool	is_deduced_type_v< deduced_type > = true
template<typename To , template< typename... > typename Op, typename... Args>
constexpr bool	is_detected_convertible_v
template<typename Expected , template< typename... > typename Op, typename... Args>
constexpr bool	is_detected_exact_v
template<template< typename... > typename Op, typename... Args>
constexpr bool	is_detected_v
template<typename Tuple >
constexpr bool	is_empty_tuple_v = ( tuple_size_v<Tuple> == 0 )
template<typename T >
constexpr bool	is_floating_point_v
template<typename >
constexpr bool	is_graph_node_v = false
template<typename T >
constexpr bool	is_graph_node_v< const_graph_node_t< T > > = true
template<typename T >
constexpr bool	is_graph_node_v< graph_node_t< T > > = true
template<typename T >
constexpr bool	is_integral_v = daw::numeric_limits<T>::is_integer
template<typename Alloc , typename = void>
constexpr bool	is_move_insertable_v
template<typename >
constexpr bool	is_nonesuch_v = false
template<template< class... > class Op, class... Args>
constexpr bool	is_nonesuch_v< nonesuch< Op, Args... > > = true
template<size_t N, typename Invokable , typename TpArgs , typename... Args>
constexpr bool	is_nothrow_callable_v
template<typename From , typename To >
constexpr bool	is_nothrow_convertible_v
template<typename T >
constexpr bool	is_number_v
template<typename >
constexpr bool	is_reference_wrapper_v = false
template<typename T , std::size_t BitSize>
constexpr bool	is_same_size_v = is_same_size<T, BitSize>::value
template<typename T , typename U >
constexpr bool	is_same_v = false
template<typename T >
constexpr bool	is_same_v< T, T > = true
template<typename T >
constexpr bool	is_signed_v
template<template< typename... > typename Primary, typename T >
constexpr bool	is_specialization_of_v = false
template<template< typename... > typename Primary, typename... Args>
constexpr bool	is_specialization_of_v< Primary, Primary< Args... > >
template<typename T >
constexpr bool	is_swappable_v = std::is_swappable_v<T>
template<typename T >
constexpr bool	is_system_integral_v = is_system_integral<T>::value
template<typename >
constexpr bool	is_tuple2_v = false
template<typename... Ts>
constexpr bool	is_tuple2_v< tuple2< Ts... > > = true
template<typename Tp , typename = void>
constexpr bool	is_tuple_like_v = false
template<typename >
constexpr bool	is_tuple_v = false
template<typename T >
constexpr bool	is_unbounded_array_v = false
template<typename T >
constexpr bool	is_unbounded_array_v< T[]> = true
template<typename T >
constexpr bool	is_unsigned_v
template<typename Value , typename... Visitors>
constexpr bool	is_visitable_v
template<auto fp>
constexpr overload_details::lift_t< fp >	lift
template<typename T >
constexpr auto	lowest_value = numeric_limits<T>::lowest( )
template<unsigned N>
constexpr UInt16	mask_from_lsb16
template<unsigned N>
constexpr UInt32	mask_from_lsb32
template<unsigned N>
constexpr UInt64	mask_from_lsb64
template<unsigned N>
constexpr UInt8	mask_from_lsb8
template<typename T >
constexpr auto	max_digits10 = numeric_limits<T>::max_digits10
template<typename T >
constexpr auto	max_value = numeric_limits<T>::max( )
template<typename T >
constexpr auto	min_value = numeric_limits<T>::min( )
constexpr never_null_t	never_null = never_null_t{ }
constexpr auto	nodiscard = nodiscard_t{ }
template<auto needle, auto... needles>
static constexpr none_of_t< decltype(needle), needle, needles... >	none_of { }
template<typename T >
constexpr T	not_null_null_value = T{ }
template<typename T >
constexpr T *	not_null_null_value< T * > = nullptr
constexpr std::nullopt_t	nullopt = std::nullopt
template<typename T , typename... Ts>
constexpr auto	pack_index_of_v
template<typename Pack >
constexpr auto	pack_size_v = deleted<Pack>
template<template< typename... > typename Pack, typename... Ts>
constexpr std::size_t	pack_size_v< Pack< Ts... > > = sizeof...( Ts )
template<typename T , typename >
constexpr auto	param_pack_index_of_v = deleted<T>
template<template< typename... > typename Pack, typename... Ts, typename T >
constexpr std::size_t	param_pack_index_of_v< Pack< Ts... >, T >
template<typename T >
constexpr bool	reset_on_take = true
constexpr sized_for_overwrite_t	sized_for_overwrite
template<typename... Args>
constexpr tag_t< Args... >	tag = tag_t<Args...>{ }
constexpr take_ownership_t	take_ownership { }
template<typename T >
constexpr template_param< T >	template_arg = template_param<T>{ }
template<typename... Ts>
constexpr template_params< Ts... >	template_args
template<auto... vals>
constexpr template_vals_t< vals... >	template_vals
constexpr auto	terminate_on_read_file_error
constexpr auto	to_lower_ascii = to_lower_ascii_t{ }
constexpr auto	to_upper_ascii = to_upper_ascii_t{ }
template<typename T >
static constexpr std::size_t	tuple2_size_v = tuple2_size<T>::value
template<typename Tuple >
constexpr size_t	tuple_size_v
template<typename T >
constexpr auto	undefined_v = impl::undefind_fn_t<T>{ }

Detailed Description

Provides structs for wrapping function pointers and callable objects to facilitate function overloading and safe invocation.

formatter will directly substitute variables into a string Uses a format like "{0} {1} {0}" which is a zero index array of the arguments

Provide a class to validate a type T after construction Validator must return true if the value is valid, false otherwise.

Provides utilities for working with parameter packs in templates.

Typedef Documentation

aligned_storage_for_t

template<typename T , typename... Ts>

using daw::aligned_storage_for_t = typedef typename impl::aligned_storage<std::max( { sizeof( T ), sizeof( Ts )... } ), std::max( { alignof( T ), alignof( Ts )... } )>::type

Definition at line 29 of file daw_aligned_storage.h.

aligned_storage_t

template<std::size_t Size, std::size_t Align = alignof( std::max_align_t )>

using daw::aligned_storage_t = typedef typename impl::aligned_storage<Size, Align>::type

Definition at line 26 of file daw_aligned_storage.h.

all_true

template<bool... values>

using daw::all_true = typedef std::bool_constant<( values and ... )>

Definition at line 46 of file cpp_17.h.

any_true

template<bool... values>

using daw::any_true = typedef std::bool_constant<( values or ... )>

Definition at line 52 of file cpp_17.h.

bad_variant_access

using daw::bad_variant_access = typedef std::bad_variant_access

Definition at line 30 of file daw_visit.h.

bit_queue

using daw::bit_queue = typedef basic_bit_queue<uint16_t>

Definition at line 135 of file daw_bit_queues.h.

bit_queue_source_native_endian

using daw::bit_queue_source_native_endian = typedef daw::conditional_t<daw::endian::native == daw::endian::little, bit_queue_source_little_endian, bit_queue_source_big_endian>

Definition at line 26 of file daw_bit_queues.h.

bool_constant

template<bool B>

using daw::bool_constant = typedef std::bool_constant<B>

Definition at line 27 of file cpp_17.h.

bounded_array_t

template<typename T , size_t N>

using daw::bounded_array_t = typedef daw::array<T, N>

Definition at line 116 of file daw_bounded_array.h.

bounded_string

using daw::bounded_string = typedef basic_bounded_string<char, 100>

Definition at line 753 of file daw_bounded_string.h.

can_call_test

template<typename N , typename Invokable , typename TpArgs , typename... Args>

using daw::can_call_test = typedef std::is_invocable< applier_t<Invokable>, decltype( std::tuple_cat( split_args<0, N::value>( std::forward_as_tuple( DAW_FWD( std::declval<Args>( ) )... ) ), std::declval<TpArgs>( ), split_args<N::value, sizeof...( Args )>( std::forward_as_tuple( DAW_FWD( std::declval<Args>( ) )... ) ) ) )>

Definition at line 73 of file daw_bind_args_at.h.

can_constant_evaluate

template<DAW_CXEVAL_FTYPE F>

using daw::can_constant_evaluate = typedef typename decltype( can_cxeval_impl::can_cxeval<F>( ) )::type

Definition at line 70 of file daw_can_constant_evaluate.h.

can_potentially_constant_construct

template<typename T , typename... Args>

using daw::can_potentially_constant_construct = typedef typename conditional_t< ( std::is_default_constructible_v<Args> and ... ), can_cxeval_impl::can_potentially_constant_construct_impl<T, Args...>, daw::traits::identity<std::false_type> >::type

Definition at line 82 of file daw_can_constant_evaluate.h.

clumpy_sparsy_const_iterator

template<typename T >

using daw::clumpy_sparsy_const_iterator = typedef clumpy_sparsy_iterator<T const>

Definition at line 27 of file daw_clumpy_sparsy.h.

common_iterator_category_t

template<typename... Its>

using daw::common_iterator_category_t = typedef daw::remove_cvref_t< decltype( iterator_traits_impl::common_iterator_tag_test_t< std::index_sequence_for<Its...> >:: test( std::declval<Its const &>( )... ) )>

Definition at line 161 of file daw_iterator_traits.h.

conditional_t

template<bool B, typename TrueType , typename FalseType >

using daw::conditional_t = typedef typename traits_details::select<B>::template type<TrueType, FalseType>

Definition at line 30 of file daw_traits_conditional.h.

conjunction

template<typename... Ts>

using daw::conjunction = typedef conjunction_t<Ts...>

Definition at line 40 of file cpp_17.h.

conjunction_t

template<typename... Ts>

using daw::conjunction_t = typedef std::bool_constant<conjunction_v<Ts...> >

Definition at line 37 of file cpp_17.h.

const_iterator_end_t

template<Range R>

using daw::const_iterator_end_t = typedef DAW_TYPEOF( std::cend( std::declval<R const &>( ) ) )

Definition at line 183 of file daw_iterator_traits.h.

const_iterator_t

template<Range R>

using daw::const_iterator_t = typedef DAW_TYPEOF( std::cbegin( std::declval<R const &>( ) ) )

Definition at line 179 of file daw_iterator_traits.h.

cstring

using daw::cstring = typedef CString<char>

Definition at line 175 of file daw_cstring.h.

detected_or

template<typename Default , template< typename... > typename Op, typename... Args>

using daw::detected_or = typedef is_detect_details::detector<Default, void, Op, Args...>

Definition at line 108 of file daw_is_detected.h.

detected_or_t

template<typename Default , template< typename... > typename Op, typename... Args>

using daw::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type

Definition at line 112 of file daw_is_detected.h.

detected_t

template<template< typename... > typename Op, typename... Args>

using daw::detected_t = typedef typename is_detect_details::detector<nonesuch<Op, Args...>, void, Op, Args...>::type

Definition at line 96 of file daw_is_detected.h.

disjunction

template<typename... Ts>

using daw::disjunction = typedef disjunction_t<Ts...>

Definition at line 164 of file cpp_17.h.

disjunction_t

template<typename... Ts>

using daw::disjunction_t = typedef std::bool_constant<disjunction_v<Ts...> >

Definition at line 161 of file cpp_17.h.

Empty

using daw::Empty = typedef empty_t

Definition at line 13 of file daw_empty.h.

enable_copy_assignment

template<typename T , bool B = true>

using daw::enable_copy_assignment = typedef traits_details::delete_copy_assignment_if< not std::is_copy_assignable_v<T> and B>

Definition at line 445 of file daw_traits_impl.h.

enable_copy_constructor

template<typename T , bool B = true>

using daw::enable_copy_constructor = typedef traits_details::delete_copy_constructor_if< not std::is_copy_constructible_v<T> and B>

Definition at line 441 of file daw_traits_impl.h.

enable_default_constructor

template<typename T , bool B = true>

using daw::enable_default_constructor = typedef traits_details::delete_default_constructor_if< not std::is_default_constructible_v<T> and B>

Definition at line 436 of file daw_traits_impl.h.

enable_if

template<bool B, typename T = std::nullptr_t>

using daw::enable_if = typedef std::enable_if<B, T>

Definition at line 19 of file daw_enable_if.h.

enable_if_t

template<bool B, typename T = std::nullptr_t>

using daw::enable_if_t = typedef std::enable_if_t<B, T>

Definition at line 22 of file daw_enable_if.h.

enable_move_assignment

template<typename T , bool B = true>

using daw::enable_move_assignment = typedef traits_details::delete_move_assignment_if< not std::is_move_assignable_v<T> and B>

Definition at line 453 of file daw_traits_impl.h.

enable_move_constructor

template<typename T , bool B = true>

using daw::enable_move_constructor = typedef traits_details::delete_move_constructor_if< not std::is_move_constructible_v<T> and B>

Definition at line 449 of file daw_traits_impl.h.

enable_when_all_t

template<typename... Traits>

using daw::enable_when_all_t = typedef enable_if_t<std::conjunction_v<Traits...> >

Definition at line 28 of file daw_enable_if.h.

enable_when_t

template<bool... B>

using daw::enable_when_t = typedef enable_if_t<( B && ... )>

Definition at line 25 of file daw_enable_if.h.

enough_args_t

template<size_t N, typename TpArgs , typename... Args>

using daw::enough_args_t = typedef std::bool_constant<( (sizeof...( Args ) + std::tuple_size_v<TpArgs>) >= N )>

Definition at line 69 of file daw_bind_args_at.h.

fn_t

template<typename T >

using daw::fn_t = typedef std::add_pointer_t<T>

Definition at line 30 of file InputIterator.h.

fnv1a_uint_t

using daw::fnv1a_uint_t = typedef conditional_t<fnv1a_impl::is_64bit_v, std::uint64_t, std::uint32_t>

Definition at line 35 of file daw_fnv1a_hash.h.

fp_t

template<typename T >

using daw::fp_t = typedef T *

Definition at line 938 of file daw_traits.h.

function_pointer_t

template<typename ResultType , typename... ArgTypes>

using daw::function_pointer_t = typedef typename utility_details::make_function_pointer_impl<ResultType, ArgTypes...>::type

Definition at line 73 of file daw_utility.h.

function_traits_t

template<typename F >

using daw::function_traits_t = typedef typename function_traits<F>::type

Definition at line 196 of file daw_utility.h.

genhash_uint_t

using daw::genhash_uint_t = typedef std::size_t

Definition at line 27 of file daw_generic_hash.h.

if_else_t

template<bool Condition, typename IfTrue , typename IfFalse >

using daw::if_else_t = typedef typename type_if_else<Condition, IfTrue, IfFalse>::type

Definition at line 308 of file daw_traits_impl.h.

if_t

template<bool Bool_, typename If_ , typename Then_ >

using daw::if_t = typedef typename std::conditional<Bool_, If_, Then_>::type

Definition at line 933 of file daw_utility.h.

ignore_one_t

template<auto , typename T >

using daw::ignore_one_t = typedef T

Definition at line 967 of file daw_traits.h.

index_constant

template<std::size_t N>

using daw::index_constant = typedef std::integral_constant<std::size_t, N>

Definition at line 847 of file daw_traits.h.

intN_t

template<std::size_t BitSize>

using daw::intN_t = typedef conditional_t< is_same_size_v<char, BitSize>, char, conditional_t< is_same_size_v<short, BitSize>, short, conditional_t< is_same_size_v<int, BitSize>, int, conditional_t< is_same_size_v<long, BitSize>, long, conditional_t<is_same_size_v<long long, BitSize>, long long, unsupported_int_size<BitSize> >> >> >

Definition at line 205 of file daw_arith_traits.h.

is_arithmetic

template<typename T >

using daw::is_arithmetic = typedef std::bool_constant<is_arithmetic_v<T> >

Definition at line 85 of file daw_arith_traits.h.

is_complete_type

template<typename T >

using daw::is_complete_type = typedef std::bool_constant<is_complete_type_v<T> >

Definition at line 914 of file daw_traits.h.

is_detected

template<template< typename... > typename Op, typename... Args>

using daw::is_detected = typedef typename is_detect_details::detector<nonesuch<Op, Args...>, void, Op, Args...>::value_t

Definition at line 91 of file daw_is_detected.h.

is_detected_convertible

template<typename To , template< typename... > typename Op, typename... Args>

using daw::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

Definition at line 125 of file daw_is_detected.h.

is_detected_exact

template<typename Expected , template< typename... > typename Op, typename... Args>

using daw::is_detected_exact = typedef std::bool_constant<is_detected_exact_v<Expected, Op, Args...> >

Definition at line 121 of file daw_is_detected.h.

is_floating_point

template<typename T >

using daw::is_floating_point = typedef std::bool_constant<is_floating_point_v<T> >

Definition at line 41 of file daw_arith_traits.h.

is_integral

template<typename T >

using daw::is_integral = typedef std::bool_constant<is_integral_v<T> >

Definition at line 30 of file daw_arith_traits.h.

is_number

template<typename T >

using daw::is_number = typedef std::bool_constant<is_number_v<T> >

Definition at line 51 of file daw_arith_traits.h.

is_reference_wrapper

template<typename T >

using daw::is_reference_wrapper = typedef std::bool_constant<is_reference_wrapper_v<T> >

Definition at line 105 of file cpp_17.h.

is_same

template<typename T , typename U >

using daw::is_same = typedef std::bool_constant<is_same_v<T, U> >

Definition at line 21 of file daw_traits_is_same.h.

is_same_size

template<typename T , std::size_t BitSize>

using daw::is_same_size = typedef std::bool_constant<( bit_count_v<T> == BitSize )>

Definition at line 196 of file daw_arith_traits.h.

is_same_t

template<typename T , typename U >

using daw::is_same_t = typedef typename std::bool_constant<is_same_v<T, U> >::type

Definition at line 24 of file daw_traits_is_same.h.

is_signed

template<typename T >

using daw::is_signed = typedef std::bool_constant<is_signed_v<T> >

Definition at line 62 of file daw_arith_traits.h.

is_specialization_of

template<template< typename... > typename Primary, typename T >

using daw::is_specialization_of = typedef std::bool_constant<is_specialization_of_v<Primary, T> >

Definition at line 890 of file daw_traits.h.

is_tuple

template<typename T >

using daw::is_tuple = typedef std::bool_constant<is_tuple_v<T> >

Definition at line 22 of file daw_tuple_traits.h.

is_unbounded_array

template<typename T >

using daw::is_unbounded_array = typedef std::bool_constant<is_unbounded_array_v<T> >

Definition at line 57 of file cpp_20.h.

is_unsigned

template<typename T >

using daw::is_unsigned = typedef std::bool_constant<is_unsigned_v<T> >

Definition at line 73 of file daw_arith_traits.h.

iter_category_t

template<typename It >

using daw::iter_category_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::iterator_category

Definition at line 42 of file daw_iterator_traits.h.

iter_const_reference_t

template<typename It >

using daw::iter_const_reference_t = typedef std::common_reference_t<iter_value_t<It> const &&, iter_reference_t<It> >

Definition at line 38 of file daw_iterator_traits.h.

iter_difference_t

template<typename It >

using daw::iter_difference_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::difference_type

Definition at line 34 of file daw_iterator_traits.h.

iter_pointer_t

template<typename It >

using daw::iter_pointer_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::pointer

Definition at line 30 of file daw_iterator_traits.h.

iter_reference_t

template<typename It >

using daw::iter_reference_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::reference

Definition at line 26 of file daw_iterator_traits.h.

iter_reference_type

template<typename T >

using daw::iter_reference_type = typedef iter_reference_t<T>

Definition at line 295 of file daw_concepts.h.

iter_value_t

template<typename It >

using daw::iter_value_t = typedef typename std::iterator_traits<daw::remove_cvref_t<It> >::value_type

Definition at line 22 of file daw_iterator_traits.h.

iter_value_type

template<typename T >

using daw::iter_value_type = typedef iter_value_t<T>

Definition at line 298 of file daw_concepts.h.

iterator_category_t

template<typename T >

using daw::iterator_category_t = typedef typename std::iterator_traits<T>::iterator_category

Definition at line 291 of file daw_concepts.h.

iterator_end_t

template<Range R>

using daw::iterator_end_t = typedef DAW_TYPEOF( std::end( std::declval<R>( ) ) )

Definition at line 176 of file daw_iterator_traits.h.

iterator_t

template<Range R>

using daw::iterator_t = typedef DAW_TYPEOF( std::begin( std::declval<R>( ) ) )

Definition at line 173 of file daw_iterator_traits.h.

make_signed_t

template<typename T >

using daw::make_signed_t = typedef typename make_signed<T>::type

Definition at line 179 of file daw_arith_traits.h.

make_unsigned_t

template<typename T >

using daw::make_unsigned_t = typedef typename make_unsigned<T>::type

Definition at line 176 of file daw_arith_traits.h.

md_stdarray_t

template<typename T , std::size_t... Extents>

using daw::md_stdarray_t = typedef typename md_stdarray<T, Extents...>::type

Definition at line 123 of file daw_array.h.

negation

template<typename B >

using daw::negation = typedef std::bool_constant<not bool( B::value )>

Definition at line 30 of file cpp_17.h.

nibble_queue

using daw::nibble_queue = typedef basic_nibble_queue<uint8_t>

Definition at line 196 of file daw_bit_queues.h.

non_owning_ptr

template<typename T >

using daw::non_owning_ptr = typedef T

Definition at line 365 of file daw_utility.h.

not_null_pointer_const_reference_t

template<typename Pointer >

using daw::not_null_pointer_const_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, Pointer, Pointer const &>

Definition at line 57 of file daw_not_null.h.

not_null_pointer_reference_t

template<typename Pointer >

using daw::not_null_pointer_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, Pointer, Pointer &>

Definition at line 53 of file daw_not_null.h.

not_null_value_const_reference_t

template<typename Pointer >

using daw::not_null_value_const_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, std::remove_pointer_t<Pointer> const &, not_null_value_type_t<Pointer> const &>

Definition at line 47 of file daw_not_null.h.

not_null_value_reference_t

template<typename Pointer >

using daw::not_null_value_reference_t = typedef std::conditional_t<std::is_pointer_v<Pointer>, std::remove_pointer_t<Pointer> const &, not_null_value_type_t<Pointer> &>

Definition at line 41 of file daw_not_null.h.

not_null_value_type_t

template<typename Pointer >

using daw::not_null_value_type_t = typedef typename not_null_value_type<Pointer>::type

Definition at line 38 of file daw_not_null.h.

not_trait

template<typename T >

using daw::not_trait = typedef std::bool_constant<not T::value>

Definition at line 108 of file cpp_17.h.

nothing

using daw::nothing = typedef empty_t

Definition at line 14 of file daw_empty.h.

pack_element_t

template<std::size_t Idx, typename Pack >

using daw::pack_element_t = typedef typename pack_element<Idx, Pack>::type

Definition at line 29 of file daw_pack_element.h.

pack_index_of

template<typename T , typename... Ts>

using daw::pack_index_of = typedef std::integral_constant<std::size_t, pack_index_of_v<T, Ts...> >

Definition at line 638 of file daw_utility.h.

pack_size

template<typename Pack >

using daw::pack_size = typedef std::integral_constant<std::size_t, pack_size_v<Pack> >

Definition at line 38 of file daw_pack_element.h.

pack_type_at

template<size_t N, typename... Ts>

using daw::pack_type_at = typedef traits::nth_type<N, Ts...>

Definition at line 624 of file daw_utility.h.

pack_type_t

template<size_t N, typename... Args>

using daw::pack_type_t = typedef typename pack_type<N, Args...>::type

Definition at line 319 of file daw_traits_impl.h.

param_pack_index_of

template<typename Pack , typename T >

using daw::param_pack_index_of = typedef std::integral_constant<std::size_t, param_pack_index_of_v<Pack, T> >

Definition at line 649 of file daw_utility.h.

pointer_to_const_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>

using daw::pointer_to_const_member_function_t = typedef typename utility_details::make_pointer_to_const_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 88 of file daw_utility.h.

pointer_to_const_volatile_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>

using daw::pointer_to_const_volatile_member_function_t = typedef typename utility_details:: make_pointer_to_const_volatile_member_function_impl<ResultType, ClassType, ArgTypes...>::type

Definition at line 93 of file daw_utility.h.

pointer_to_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>

using daw::pointer_to_member_function_t = typedef typename utility_details::make_pointer_to_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 78 of file daw_utility.h.

pointer_to_volatile_member_function_t

template<typename ResultType , typename ClassType , typename... ArgTypes>

using daw::pointer_to_volatile_member_function_t = typedef typename utility_details::make_pointer_to_volatile_member_function_impl< ResultType, ClassType, ArgTypes...>::type

Definition at line 83 of file daw_utility.h.

range_category_t

template<Range R>

using daw::range_category_t = typedef iter_category_t<iterator_t<R> >

Definition at line 196 of file daw_iterator_traits.h.

range_const_reference_t

template<Range R>

using daw::range_const_reference_t = typedef iter_const_reference_t<iterator_t<R> >

Definition at line 193 of file daw_iterator_traits.h.

range_reference_t

template<Range R>

using daw::range_reference_t = typedef iter_reference_t<iterator_t<R> >

Definition at line 190 of file daw_iterator_traits.h.

range_value_t

template<Range R>

using daw::range_value_t = typedef iter_value_t<iterator_t<R> >

Definition at line 187 of file daw_iterator_traits.h.

remove_array_ref_t

template<typename T >

using daw::remove_array_ref_t = typedef typename remove_array_ref<T>::type

Definition at line 22 of file daw_remove_array_ref.h.

remove_cvref_t

template<typename T >

using daw::remove_cvref_t = typedef std::remove_cv_t<std::remove_reference_t<T> >

Definition at line 17 of file daw_remove_cvref.h.

remove_cvrvref_t

template<typename T >

using daw::remove_cvrvref_t = typedef std::conditional_t<std::is_rvalue_reference_v<T>, remove_cvref_t<T>, T>

Make rvalue references remove_cvref_t<T> and alone otherwise.

Definition at line 21 of file daw_remove_cvref.h.

remove_rvalue_ref_t

template<typename T >

using daw::remove_rvalue_ref_t = typedef daw::conditional_t<std::is_rvalue_reference_v<T>, daw::remove_cvref_t<T>, T>

Definition at line 19 of file daw_tuple_forward.h.

required

template<bool B, typename T = std::nullptr_t>

using daw::required = typedef std::enable_if_t<B, T>

Definition at line 311 of file daw_traits_impl.h.

root_type_t

template<typename T >

using daw::root_type_t = typedef std::remove_cv_t<std::remove_pointer_t<std::decay_t<T> >>

Definition at line 80 of file daw_concepts.h.

rvalue_to_value_t

template<typename T >

using daw::rvalue_to_value_t = typedef typename rvalue_to_value<T>::type

Definition at line 932 of file daw_traits.h.

safe_string

template<typename SanitizeFunction >

using daw::safe_string = typedef basic_safe_string<SanitizeFunction, char>

Definition at line 67 of file daw_safe_string.h.

safe_u16string

template<typename SanitizeFunction >

using daw::safe_u16string = typedef basic_safe_string<SanitizeFunction, char16_t>

Definition at line 73 of file daw_safe_string.h.

safe_u32string

template<typename SanitizeFunction >

using daw::safe_u32string = typedef basic_safe_string<SanitizeFunction, char32_t>

Definition at line 76 of file daw_safe_string.h.

safe_wstring

template<typename SanitizeFunction >

using daw::safe_wstring = typedef basic_safe_string<SanitizeFunction, wchar_t>

Definition at line 70 of file daw_safe_string.h.

String

using daw::String = typedef daw::string::string_details::BasicString<char>

Definition at line 512 of file daw_string.h.

switch_t

template<std::size_t Index, typename... Cases>

using daw::switch_t = typedef pack_element_t<Index, pack_list<Cases...> >

Definition at line 853 of file daw_traits.h.

tuple2_element_t

template<std::size_t Idx, typename Tuple >

using daw::tuple2_element_t = typedef typename tuple2_element<Idx, Tuple>::type

Definition at line 157 of file daw_tuple2.h.

type_n_t

template<size_t N, typename... Args>

using daw::type_n_t = typedef traits::nth_element<N, Args...>

Definition at line 295 of file daw_traits_impl.h.

u16bounded_string

using daw::u16bounded_string = typedef basic_bounded_string<char16_t, 100>

Definition at line 755 of file daw_bounded_string.h.

u32bounded_string

using daw::u32bounded_string = typedef basic_bounded_string<char32_t, 100>

Definition at line 756 of file daw_bounded_string.h.

UInt

template<unsigned Bits>

using daw::UInt = typedef conditional_t< ( Bits == 8 ), UInt8, conditional_t< ( Bits == 16 ), UInt16, conditional_t<( Bits == 32 ), UInt32, conditional_t<( Bits == 64 ), UInt64, InvalidUIntSize> >> >

Definition at line 55 of file daw_uint_types.h.

uintN_t

template<std::size_t BitSize>

using daw::uintN_t = typedef conditional_t< is_same_size_v<char, BitSize>, unsigned char, conditional_t< is_same_size_v<short, BitSize>, unsigned short, conditional_t< is_same_size_v<int, BitSize>, unsigned int, conditional_t< is_same_size_v<long, BitSize>, unsigned long, conditional_t<is_same_size_v<unsigned long long, BitSize>, long long, unsupported_int_size<BitSize> >> >> >

Definition at line 216 of file daw_arith_traits.h.

void_t

template<typename... >

using daw::void_t = typedef void

Definition at line 945 of file daw_traits.h.

wbounded_string

using daw::wbounded_string = typedef basic_bounded_string<wchar_t, 100>

Definition at line 754 of file daw_bounded_string.h.

WString

using daw::WString = typedef daw::string::string_details::BasicString<wchar_t>

Definition at line 513 of file daw_string.h.

Enumeration Type Documentation

endian

enum class daw::endian

strong

Enumerator
little
big
native

Definition at line 21 of file daw_endian.h.

keep_n_order

enum class daw::keep_n_order

strong

Enumerator
ascending
descending

Definition at line 20 of file daw_keep_n.h.

UInt16

enum class daw::UInt16 : std::uint16_t

strong

Definition at line 27 of file daw_uint_types.h.

UInt32

enum class daw::UInt32 : std::uint32_t

strong

Definition at line 26 of file daw_uint_types.h.

UInt64

enum class daw::UInt64 : std::uint64_t

strong

Definition at line 25 of file daw_uint_types.h.

UInt8

enum class daw::UInt8 : std::uint8_t

strong

Definition at line 28 of file daw_uint_types.h.

wait_status

enum class daw::wait_status

strong

Enumerator
found
timeout

Definition at line 20 of file daw_atomic_wait.h.

Function Documentation

advance()

template<typename Iterator , typename Distance >

constexpr void daw::advance ( Iterator &  it, Distance  n  )

constexpr

Advance iterator n steps.

Template Parameters

Iterator	Type of iterator to advance
Distance	A type convertible to an integral type

Parameters

it	iterator to advance
n	how far to move iterator

Definition at line 111 of file cpp_17_iterator.h.

advance_many() [1/2]

template<typename Distance , typename Iterator >

constexpr void daw::advance_many ( Distance  d, Iterator &  it  )

constexpr

Definition at line 73 of file daw_algorithm.h.

advance_many() [2/2]

template<typename Distance , typename Iterator , typename Iterator2 , typename... Iterators>

constexpr void daw::advance_many ( Distance  d, Iterator &  it, Iterator2 &  it2, Iterators &...  its  )

constexpr

Definition at line 79 of file daw_algorithm.h.

any_if()

template<typename... Predicates>
requires ( (Fn<Predicates, bool()> or std::convertible_to<Predicates, bool>) and ...)

constexpr bool daw::any_if ( Predicates &&...  predicates )

constexpr

Definition at line 17 of file daw_any_if.h.

any_of_f()

template<typename... Ts>

constexpr auto daw::any_of_f ( Ts &&...  needles )

constexprnoexcept

Definition at line 41 of file daw_view_tags.h.

append()

template<typename Container , typename... Args>

constexpr auto daw::append ( Container &  container, Args &&...  args  )

constexpr

Definition at line 373 of file daw_utility.h.

apply() [1/10]

template<bool use_invoke = true, typename F , typename Tuple >

constexpr decltype(auto) daw::apply ( F &&  f, Tuple &&  t  )

inlineconstexpr

Definition at line 147 of file daw_apply.h.

apply() [2/10]

template<typename F , typename... Ts>

constexpr decltype(auto) daw::apply ( F &&  f, tuple< Ts... > &&  t  )

inlineconstexpr

Definition at line 294 of file daw_tuple.h.

apply() [3/10]

template<typename F , typename... Ts>

constexpr decltype(auto) daw::apply ( F &&  f, tuple< Ts... > &  t  )

inlineconstexpr

Definition at line 280 of file daw_tuple.h.

apply() [4/10]

template<typename F , typename... Ts>

constexpr decltype(auto) daw::apply ( F &&  f, tuple< Ts... > const &&  t  )

inlineconstexpr

Definition at line 302 of file daw_tuple.h.

apply() [5/10]

template<typename F , typename... Ts>

constexpr decltype(auto) daw::apply ( F &&  f, tuple< Ts... > const &  t  )

inlineconstexpr

Definition at line 287 of file daw_tuple.h.

apply() [6/10]

template<typename Func , typename... Ts>

constexpr decltype(auto) daw::apply ( Func &&  func, fwd_pack< Ts... > &&  p  )

constexprnoexcept

Definition at line 119 of file daw_fwd_pack_apply.h.

apply() [7/10]

template<typename Func , typename... Ts>

constexpr decltype(auto) daw::apply ( tuple2< Ts... > &&  tp, Func &&  fn  )

inlineconstexpr

Definition at line 259 of file daw_tuple2.h.

apply() [8/10]

template<typename Func , typename... Ts>

constexpr decltype(auto) daw::apply ( tuple2< Ts... > &  tp, Func &&  fn  )

inlineconstexpr

Definition at line 244 of file daw_tuple2.h.

apply() [9/10]

template<typename Func , typename... Ts>

constexpr decltype(auto) daw::apply ( tuple2< Ts... > const &&  tp, Func &&  fn  )

inlineconstexpr

Definition at line 251 of file daw_tuple2.h.

apply() [10/10]

template<typename Func , typename... Ts>

constexpr decltype(auto) daw::apply ( tuple2< Ts... > const &  tp, Func &&  fn  )

inlineconstexpr

Definition at line 236 of file daw_tuple2.h.

apply_string() [1/3]

template<typename Arg , typename Callable >

constexpr decltype(auto) daw::apply_string ( Callable &&  callable, daw::string_view  str  )

constexpr

Apply the reified string as the types specified as Arg to the Callable.

Template Parameters

Arg	Type of expected data to find in string
Callable	Callable function type that will accept the arg in string

Parameters

callable	Function to apply argument to
str	String data with string encoded argument

Returns

result of callable

Definition at line 474 of file daw_parse_to.h.

apply_string() [2/3]

template<typename... Args, typename Callable >

constexpr decltype(auto) daw::apply_string ( Callable &&  callable, daw::string_view  str, daw::string_view  delemiter  )

constexpr

Apply the reified string as the types specified as Args... to the Callable.

Template Parameters

Args	Types of expected data to find in string
Callable	Callable function type that will accept the args in string

Parameters

callable	Function to apply arguments to
str	String data with string encoded arguments
delemiter	split what string arguments on

Returns

result of callable

Definition at line 451 of file daw_parse_to.h.

apply_string() [3/3]

template<typename... Args, typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>

constexpr decltype(auto) daw::apply_string ( Callable &&  callable, daw::string_view  str, Splitter &&  splitter  )

constexpr

Apply the reified string as the types specified as Args... to the Callable.

Template Parameters

Args	Types of expected data to find in string
Callable	Callable function type that will accept the args in string
Splitter	A predicate that will return true on the string parts to split on

Parameters

callable	Function to apply arguments to
str	String data with string encoded arguments
splitter	Function to split string into arguments

Returns

result of callable

Definition at line 428 of file daw_parse_to.h.

apply_string2() [1/2]

template<typename Callable >

constexpr decltype(auto) daw::apply_string2 ( Callable &&  callable, daw::string_view  str, daw::string_view  delemiter  )

constexpr

Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.

Template Parameters

Callable

Can be called with operator( )

Parameters

callable	a function that takes deducted arguments
str	String containing encoded values
delemiter	split what string arguments on

Returns

The result of callable

Definition at line 407 of file daw_parse_to.h.

apply_string2() [2/2]

template<typename Callable , typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>

constexpr decltype(auto) daw::apply_string2 ( Callable &&  callable, daw::string_view  str, Splitter &&  splitter  )

constexpr

Apply the reified string as the types deducted from the Callable to the Callable. This may have unexpected results if strings are ot controlled.

Template Parameters

Callable	Can be called with operator( )
Splitter	Callable splitter that returns the next position of a value

Parameters

callable	a function that takes deducted arguments
str	String containing encoded values
splitter	Function to split string into arguments

Returns

The result of callable

Definition at line 389 of file daw_parse_to.h.

are_set()

template<typename Integer , typename MaskBit , typename... MaskBits>

constexpr bool daw::are_set ( Integer  value, MaskBit  mask_bit, MaskBits...  mask_bits  )

constexprnoexcept

Definition at line 61 of file daw_bit.h.

array_cmp()

template<typename T , typename Compare = std::equal_to<>, typename U = std::enable_if_t<std::is_array_v<remove_array_ref_t<T>>, remove_array_ref_t<T>>>

constexpr auto daw::array_cmp ( T &&  lhs, T &&  rhs, Compare const &  cmp = Compare{ }  )

constexpr

Definition at line 35 of file daw_array_compare.h.

as_char_array()

template<typename From >

auto daw::as_char_array ( From &&  from )

noexcept

Definition at line 780 of file daw_utility.h.

as_const()

template<typename T >

constexpr std::add_const_t< T > & daw::as_const ( T const &  t )

constexprnoexcept

Definition at line 111 of file cpp_17.h.

AsciiLower() [1/2]

constexpr char daw::AsciiLower ( char  chr )

constexprnoexcept

Definition at line 306 of file daw_utility.h.

AsciiLower() [2/2]

template<typename CharType , typename Traits , typename Allocator >

constexpr auto daw::AsciiLower ( std::basic_string< CharType, Traits, Allocator >  str )

constexprnoexcept

Definition at line 326 of file daw_utility.h.

AsciiUpper() [1/2]

constexpr char daw::AsciiUpper ( char  chr )

constexprnoexcept

Definition at line 298 of file daw_utility.h.

AsciiUpper() [2/2]

template<typename CharType , typename Traits , typename Allocator >

constexpr auto daw::AsciiUpper ( std::basic_string< CharType, Traits, Allocator >  str )

constexprnoexcept

Definition at line 316 of file daw_utility.h.

atomic_wait_for()

template<typename T , typename Rep , typename Period >

wait_status daw::atomic_wait_for	(	std::atomic< T > const *	object,
		T const &	old,
		std::chrono::duration< Rep, Period > const &	rel_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits for the atomic object to change from the old value or until the timeout expires.

This function blocks the calling thread, periodically polling the atomic object, and returns as soon as the atomic value differs from the specified old value or the relative timeout period elapses.

Template Parameters

T	The type of the atomic object.
Rep	The representation type of the relative time duration.
Period	The tick period type of the relative time duration.

Parameters

object	Pointer to the atomic object to wait on.
old	The value that the atomic object is expected to differ from.
rel_time	The maximum duration to wait before timing out.
order	The memory order to use for atomic load operations. Defaults to std::memory_order_acquire.

Returns

A wait_status indicating whether the atomic value changed or the timeout expired.

Definition at line 92 of file daw_atomic_wait.h.

atomic_wait_if()

template<typename T >

void daw::atomic_wait_if	(	std::atomic< T > const *	object,
		Fn< bool(T)> auto &&	predicate,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the atomic object satisfies the given predicate.

This function blocks the calling thread until the value of the atomic object pointed to by object satisfies the provided predicate.

Template Parameters

T	The type of the atomic object.
Fn	A templated function type that takes a value of type T and returns bool.

Parameters

object	Pointer to the atomic object to wait on.
predicate	A callable object (such as a lambda or function object) that takes a value of type T and returns a boolean indicating whether the condition is met.
order	The memory order to use. Defaults to std::memory_order_acquire.

Definition at line 171 of file daw_atomic_wait.h.

atomic_wait_if_for()

template<typename T , typename Rep , typename Period >

wait_status daw::atomic_wait_if_for	(	std::atomic< T > const *	object,
		Fn< bool(T)> auto &&	predicate,
		std::chrono::duration< Rep, Period > const &	rel_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits for an atomic object to satisfy a predicate within a specified time duration.

This function blocks the calling thread until the predicate applied to the atomic object evaluates to true or the specified timeout period elapses.

Template Parameters

T	The type of the atomic object.
Fn	A callable type that returns a boolean value when applied to an object of type T.
Rep	A type representing the number of ticks of the time duration.
Period	A std::ratio type representing the tick period of the time duration.

Parameters

object	Pointer to the atomic object to wait on.
predicate	Predicate function to apply to the atomic object's value.
rel_time	The relative time duration to wait for the predicate to become true.
order	The memory order to use for atomic operations. Defaults to std::memory_order_acquire.

Returns

Returns wait_status::found if the predicate evaluates to true before the timeout, and wait_status::timeout otherwise.

Definition at line 210 of file daw_atomic_wait.h.

atomic_wait_if_until()

template<typename T , typename Clock , typename Duration >

wait_status daw::atomic_wait_if_until	(	std::atomic< T > const *	object,
		Fn< bool(T)> auto &&	predicate,
		std::chrono::time_point< Clock, Duration > const &	timeout_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the atomic object satisfies the given predicate or the absolute timeout time is reached.

This function blocks the calling thread until the atomic value pointed to by object satisfies the predicate function or the specified timeout time timeout_time is reached.

Template Parameters

T	The type of the atomic object.
Clock	The clock used for the timeout.
Duration	The duration type used by the clock.
Fn	A callable type that takes a value of type T and returns a bool.

Parameters

object	Pointer to the atomic object to wait on.
predicate	A callable that takes the atomic object's value and returns whether it satisfies the condition.
timeout_time	The absolute time point by which the wait operation should be aborted if the predicate is not satisfied.
order	The memory order to use. Defaults to std::memory_order_acquire.

Returns

A wait_status enum indicating whether the predicate was satisfied or a timeout occurred.

Definition at line 267 of file daw_atomic_wait.h.

atomic_wait_until()

template<typename T , typename Clock , typename Duration >

wait_status daw::atomic_wait_until	(	std::atomic< T > const *	object,
		T const &	old,
		std::chrono::time_point< Clock, Duration > const &	timeout_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the atomic object changes from the specified value or the timeout time is reached.

This function blocks the calling thread until the atomic value pointed to by object is not equal to old or until the specified timeout_time is reached.

Template Parameters

T	The type of the atomic object.
Clock	The clock type used to measure the timeout.
Duration	The duration type used to represent the timeout.

Parameters

object	Pointer to the atomic object to wait on.
old	The value that the atomic object is expected to change from
timeout_time	The time point at which the wait is aborted if the value has not been reached.
order	The memory order to use. Defaults to std::memory_order_acquire.

Returns

A wait_status indicating whether the wait was successful or if it timed out.

Definition at line 144 of file daw_atomic_wait.h.

atomic_wait_value_equal()

template<typename T >

void daw::atomic_wait_value_equal	(	std::atomic< T > const *	object,
		T const &	desired_value,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the atomic object reaches the desired value.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value.

Template Parameters

T	The type of the atomic object.

Parameters

object	Pointer to the atomic object to wait on.
desired_value	The value that the atomic object is expected to reach.
order	The memory order to use. Defaults to std::memory_order_acquire.

Definition at line 289 of file daw_atomic_wait.h.

atomic_wait_value_equal_for()

template<typename T , typename Rep , typename Period >

wait_status daw::atomic_wait_value_equal_for	(	std::atomic< T > const *	object,
		T const &	desired_value,
		std::chrono::duration< Rep, Period > const &	rel_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the atomic object reaches the desired value or the relative time duration has elapsed.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value or the specified relative time duration rel_time has elapsed.

Template Parameters

T	The type of the atomic object.
Rep	The type representing the number of ticks.
Period	The type representing the tick period.

Parameters

object	Pointer to the atomic object to wait on.
desired_value	The value that the atomic object is expected to reach.
rel_time	The maximum duration to wait for the atomic object to reach the desired value.
order	The memory order to use. Defaults to std::memory_order_acquire.

Returns

A wait_status enum indicating whether the desired value was found or a timeout occurred.

Definition at line 323 of file daw_atomic_wait.h.

atomic_wait_value_equal_until()

template<typename T , typename Clock , typename Duration >

wait_status daw::atomic_wait_value_equal_until	(	std::atomic< T > const *	object,
		T const &	desired_value,
		std::chrono::time_point< Clock, Duration > const &	timeout_time,
		std::memory_order	order = std::memory_order_acquire
	)

Waits until the specified object reaches the desired value or the timeout is reached.

This function blocks the calling thread until the atomic value pointed to by object equals desired_value or the specified timeout time timeout_time is reached.

Template Parameters

T	The type of the atomic object.
Clock	The clock used for the timeout.
Duration	The duration type used by the clock.

Parameters

object	Pointer to the atomic object to wait on.
desired_value	The value that the atomic object is expected to reach.
timeout_time	The absolute time point by which the wait operation should be aborted if the desired value is not reached.
order	The memory order to use. Defaults to std::memory_order_acquire.

Returns

A wait_status enum indicating whether the desired value was found or a timeout occurred.

Definition at line 358 of file daw_atomic_wait.h.

back_inserter()

template<typename Container >

daw::back_inserter

(

Container

)

-> back_inserter< Container >

basic_bounded_string() [1/2]

template<typename... Chars, std::enable_if_t< daw::traits::all_same_v< char, Chars... >, std::nullptr_t > = nullptr>

daw::basic_bounded_string

(

Chars...

)

-> basic_bounded_string< char, sizeof...(Chars)>

basic_bounded_string() [2/2]

template<typename CharT , size_t N>

daw::basic_bounded_string

(

CharT

const(&)[N]

)

-> basic_bounded_string< CharT, N >

begin_at() [1/2]

template<typename Container >

constexpr auto daw::begin_at ( Container &  container, size_t  n  ) -> decltype( std::begin( container ) )

constexprnoexcept

Take iterator return from begin of a container and return the result of running next with n steps.

Template Parameters

Container

Container type iterator will come from

Parameters

container	container to get iterator from
n	how many steps to move forward from begin

Returns

an iterator referencing a value in container n steps from begin

Definition at line 218 of file daw_algorithm.h.

begin_at() [2/2]

template<typename Container >

constexpr auto daw::begin_at ( Container const &  container, size_t  n  ) -> decltype( std::cbegin( container ) )

constexprnoexcept

Take iterator return from begin of a container and return the result of running next with n steps.

Template Parameters

Container

Container type iterator will come from

Parameters

container	container to get iterator from
n	how many steps to move forward from begin

Returns

an iterator referencing a value in container n steps from begin

Definition at line 236 of file daw_algorithm.h.

bench_n_test()

template<size_t Runs, char delem = '\n', typename Test , typename... Args>

DAW_ATTRIB_NOINLINE auto daw::bench_n_test ( std::string const &  title, Test &&  test_callable, Args const &...  args  )

noexcept

Template Parameters

Runs	Number of runs to do
delem	delemiter in output
Test	Callable type to benchmark
Args	types passed to callable

Parameters

title	Title of benchmark
test_callable	callable to benchmark
args	arg values to pass to callable

Returns

last value from callable

Definition at line 206 of file daw_benchmark.h.

bench_n_test_json()

template<size_t Runs, typename Function , typename... Args>

DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > daw::bench_n_test_json ( Function &&  func, Args &&...  args  )

noexcept

Template Parameters

Runs	Number of runs
Function	Callable type to be timed
Args	types to pass to callable

Parameters

func	Callable value to bench
args	args values to pass to func

Returns

last result timing counts of runs

Definition at line 480 of file daw_benchmark.h.

bench_n_test_json_val()

template<size_t Runs, typename Validator , typename Function , typename... Args>

DAW_ATTRIB_NOINLINE std::vector< std::chrono::nanoseconds > daw::bench_n_test_json_val ( Validator &&  validator, Function &&  func, Args &&...  args  )

noexcept

Template Parameters

Runs	Number of runs
Validator	Callable to validate results
Function	Callable type to be timed
Args	types to pass to callable

Parameters

validator	validatio object that takes func's result as arg
func	Callable value to bench
args	args values to pass to func

Returns

last result timing counts of runs

Definition at line 532 of file daw_benchmark.h.

bench_n_test_mbs()

template<size_t Runs, char delem = '\n', typename Test , typename... Args>

DAW_ATTRIB_NOINLINE auto daw::bench_n_test_mbs ( std::string const &  title, size_t  bytes, Test &&  test_callable, Args const &...  args  )

noexcept

Definition at line 370 of file daw_benchmark.h.

bench_n_test_mbs2()

template<size_t Runs, char delem = '\n', typename Validator , typename Function , typename... Args>

DAW_ATTRIB_NOINLINE std::array< double, Runs > daw::bench_n_test_mbs2 ( std::string const &  , size_t  , Validator &&  validator, Function &&  func, Args const &...  args  )

noexcept

Template Parameters

Runs	Number of runs
delem	Delemiter in output
Validator	Callable to validate results
Function	Callable type to be timed
Args	types to pass to callable

Parameters

title	Title for output
bytes	Size of data in bytes
validator	validatio object that takes func's result as arg
func	Callable value to bench
args	args values to pass to func

Returns

last result timing counts of runs

Definition at line 315 of file daw_benchmark.h.

bench_test()

template<typename Test , typename... Args>

DAW_ATTRIB_NOINLINE auto daw::bench_test	(	std::string const &	title,
		Test &&	test_callable,
		Args &&...	args
	)

Definition at line 135 of file daw_benchmark.h.

bench_test2()

template<typename Test , typename... Args>

DAW_ATTRIB_NOINLINE auto daw::bench_test2	(	std::string const &	title,
		Test &&	test_callable,
		size_t	item_count,
		Args &&...	args
	)

Definition at line 162 of file daw_benchmark.h.

benchmark()

template<typename F >

DAW_ATTRIB_NOINLINE double daw::benchmark

(

F &&

func

)

Definition at line 35 of file daw_benchmark.h.

bfs_walk() [1/2]

template<typename ChildOrder = UnorderedWalk, typename T , typename Function >

void daw::bfs_walk	(	daw::graph_t< T > &	graph,
		daw::node_id_t	start_node_id,
		Function &&	func,
		ChildOrder	ord = ChildOrder{ }
	)

Definition at line 539 of file daw_graph_algorithm.h.

bfs_walk() [2/2]

template<typename ChildOrder = UnorderedWalk, typename T , typename Function >

void daw::bfs_walk	(	daw::graph_t< T > const &	graph,
		daw::node_id_t	start_node_id,
		Function &&	func,
		ChildOrder	ord = ChildOrder{ }
	)

Definition at line 532 of file daw_graph_algorithm.h.

bidirectional_counting_iterator()

template<typename BiDirectionalIterator >

daw::bidirectional_counting_iterator

(

BiDirectionalIterator

)

-> bidirectional_counting_iterator< BiDirectionalIterator >

bind_args_at()

template<std::size_t N, typename Invokable , typename... Args>

constexpr auto daw::bind_args_at ( Invokable &&  func, Args &&...  args  )

constexpr

Definition at line 133 of file daw_bind_args_at.h.

bind_front()

template<typename Function , typename... Params>

daw::bind_front	(	Function	,
		Params...
	)		-> bind_front< Function, Params... >

bit_cast()

template<typename To , typename From >

To daw::bit_cast ( From &&  from )

noexcept

Definition at line 32 of file daw_bit_cast.h.

bit_cast_copy()

template<typename T = deduced_type, typename Iterator , typename OutputIterator >

void daw::bit_cast_copy	(	Iterator	first,
		Iterator	last,
		OutputIterator	first_out
	)

Definition at line 51 of file daw_bit_cast_util.h.

bit_cast_for_each()

template<typename T , typename Iterator , typename Function >

void daw::bit_cast_for_each ( Iterator  first, Iterator  last, Function &&  func  )

noexcept

Definition at line 21 of file daw_bit_cast_util.h.

bit_cast_transform()

template<typename T , typename U = deduced_type, typename Iterator , typename OutputIterator , typename Function >

void daw::bit_cast_transform	(	Iterator	first,
		Iterator	last,
		OutputIterator	first_out,
		Function &&	func
	)

Definition at line 33 of file daw_bit_cast_util.h.

bitcount() [1/2]

template<typename Value >

constexpr std::size_t daw::bitcount ( Value  value )

constexprnoexcept

Definition at line 409 of file daw_utility.h.

bitcount() [2/2]

template<typename Value , typename... T>

constexpr std::size_t daw::bitcount ( Value  value, T...  values  )

constexprnoexcept

Definition at line 419 of file daw_utility.h.

block_append_from()

template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>

constexpr void daw::block_append_from ( vector< T, Allocator > &  v, InputIterator  first, InputIterator  last, std::size_t  block_size = 512  )

constexpr

Definition at line 1312 of file vector.h.

block_create_from()

template<typename T , typename Allocator = std::allocator<T>, input_iterator InputIterator>

constexpr vector< T, Allocator > daw::block_create_from ( InputIterator  first, InputIterator  last, std::size_t  block_size = 512  )

constexpr

Definition at line 1336 of file vector.h.

bounded_hash_map()

template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>

daw::bounded_hash_map

(

std::pair< Key, Value > const (&&)

items[N]

)

-> bounded_hash_map< Key, Value, N, Hash >

bounded_hash_map_item_t()

template<typename Key , typename Value >

daw::bounded_hash_map_item_t	(	Key	,
		Value
	)		-> bounded_hash_map_item_t< Key, Value >

breakpoint()

constexpr void daw::breakpoint ( )

constexprnoexcept

Definition at line 439 of file daw_utility.h.

can_extract() [1/2]

template<typename T , typename... Args>

constexpr bool daw::can_extract ( std::variant< Args... > &&  var )

constexprnoexcept

Definition at line 86 of file daw_variant_cast.h.

can_extract() [2/2]

template<typename T , typename... Args>

constexpr bool daw::can_extract ( std::variant< Args... > const &  var )

constexprnoexcept

Definition at line 81 of file daw_variant_cast.h.

can_fit()

template<typename IntegerDest , typename IntegerSource >

constexpr bool daw::can_fit ( IntegerSource const  value )

constexprnoexcept

Definition at line 425 of file daw_utility.h.

cast()

template<typename T , bool AllowDownSignCast = false, typename U >

constexpr decltype(auto) daw::cast ( U &&  v )

constexpr

Definition at line 919 of file daw_utility.h.

checked_from_code()

template<typename... ExpectedExceptions, typename Function , typename... Args>

auto daw::checked_from_code	(	Function	func,
		Args &&...	args
	)

Definition at line 390 of file daw_checked_expected.h.

chunk_iterator()

template<typename Iterator >

daw::chunk_iterator	(	Iterator	,
		std::size_t
	)		-> chunk_iterator< Iterator >

cibegin() [1/3]

template<typename T >

constexpr auto daw::cibegin ( T &&  container )

constexprnoexcept

Definition at line 217 of file daw_indexed_iterator.h.

cibegin() [2/3]

template<typename T , size_t N>

constexpr auto daw::cibegin ( T const (&)  container[N] )

constexprnoexcept

Definition at line 261 of file daw_indexed_iterator.h.

cibegin() [3/3]

template<typename T , size_t N>

constexpr auto daw::cibegin ( T(&)  container[N] )

constexprnoexcept

Definition at line 256 of file daw_indexed_iterator.h.

ciend() [1/3]

template<typename T >

constexpr auto daw::ciend ( T &&  container )

constexprnoexcept

Definition at line 236 of file daw_indexed_iterator.h.

ciend() [2/3]

template<typename T , size_t N>

constexpr auto daw::ciend ( T const (&)  container[N] )

constexprnoexcept

Definition at line 281 of file daw_indexed_iterator.h.

ciend() [3/3]

template<typename T , size_t N>

constexpr auto daw::ciend ( T(&)  container[N] )

constexprnoexcept

Definition at line 276 of file daw_indexed_iterator.h.

cmp_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_equal ( T  t, U  u  )

constexprnoexcept

Definition at line 25 of file daw_int_cmp.h.

cmp_greater()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_greater ( T  t, U  u  )

constexprnoexcept

Definition at line 70 of file daw_int_cmp.h.

cmp_greater_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_greater_equal ( T  t, U  u  )

constexprnoexcept

Definition at line 84 of file daw_int_cmp.h.

cmp_less()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_less ( T  t, U  u  )

constexprnoexcept

Definition at line 55 of file daw_int_cmp.h.

cmp_less_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_less_equal ( T  t, U  u  )

constexprnoexcept

Definition at line 77 of file daw_int_cmp.h.

cmp_not_equal()

template<typename T , typename U , std::enable_if_t< daw::is_integral_v< T > and daw::is_integral_v< U >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::cmp_not_equal ( T  t, U  u  )

constexprnoexcept

Definition at line 40 of file daw_int_cmp.h.

construct_at() [1/2]

template<typename T , typename Storage , typename... Args>

T * daw::construct_at ( Storage *  p, Args &&...  args  )

inline

Definition at line 21 of file daw_construct_at.h.

construct_at() [2/2]

template<typename T , typename... Args>

constexpr T * daw::construct_at ( T *  p, Args &&...  args  )

constexpr

Definition at line 203 of file daw_vector.h.

construct_from() [1/5]

template<typename Destination , typename ExpectedArg >

constexpr decltype(auto) daw::construct_from ( daw::string_view  str )

constexpr

Contructs an object from the arguments specified in the string using a default delemiter of " ".

Template Parameters

Destination	The type of object to construct
ExpectedArg	The type of value to parse out of the string

Parameters

str	String containing encoded values

Returns

A constructed Destination

Definition at line 361 of file daw_parse_to.h.

construct_from() [2/5]

template<typename Destination , typename... ExpectedArgs>

constexpr decltype(auto) daw::construct_from ( daw::string_view  str, daw::string_view  delemiter  )

constexpr

Contructs an object from the arguments specified in the string.

Template Parameters

Destination	The type of object to construct
ExpectedArgs	The types of values to parse out of the string

Parameters

str	String containing encoded values
delemiter	that str is split on

Returns

A constructed Destination

Definition at line 347 of file daw_parse_to.h.

construct_from() [3/5]

template<typename Destination , typename... ExpectedArgs, typename Splitter , std::enable_if_t< std::is_invocable_v< Splitter, daw::string_view >, std::nullptr_t > = nullptr>

constexpr decltype(auto) daw::construct_from ( daw::string_view  str, Splitter &&  splitter  )

constexpr

Contructs an object from the arguments specified in the string.

Template Parameters

Destination	The type of object to construct
ExpectedArgs	The types of values to parse out of the string
Splitter	Callable splitter that returns the next position of a value

Parameters

str	String containing encoded values
splitter	split what string arguments on

Returns

A constructed Destination

Definition at line 332 of file daw_parse_to.h.

construct_from() [4/5]

template<typename Destination , typename... Args>

constexpr decltype(auto) daw::construct_from ( std::tuple< Args... > &&  args )

constexprnoexcept

Definition at line 680 of file daw_utility.h.

construct_from() [5/5]

template<typename Destination , typename... Args>

constexpr decltype(auto) daw::construct_from ( std::tuple< Args... > const &  args )

constexprnoexcept

Definition at line 688 of file daw_utility.h.

contains()

template<typename Container , typename Item >

constexpr bool daw::contains ( Container const &  container, Item const &  item  )

constexprnoexcept

Definition at line 378 of file daw_utility.h.

contiguous_view() [1/4]

template<ContiguousContainer Container>

daw::contiguous_view

(

Container &&

c

)

-> contiguous_view< std::remove_reference_t< decltype(*std::data(c))> >

contiguous_view() [2/4]

template<typename T >

daw::contiguous_view	(	T *	,
		std::size_t
	)		-> contiguous_view< T >

contiguous_view() [3/4]

template<typename T >

daw::contiguous_view	(	T *	,
		T *
	)		-> contiguous_view< T >

contiguous_view() [4/4]

template<typename T , std::size_t N>

daw::contiguous_view

(

T(&)

[N]

)

-> contiguous_view< T >

contract_failure()

DAW_ATTRIB_NOINLINE void daw::contract_failure ( )

inline

Definition at line 38 of file daw_contract.h.

copy()

template<typename T >

constexpr T daw::copy ( T &&  value )

constexprnoexcept

Definition at line 264 of file daw_utility.h.

copy_n()

template<typename Iterator , typename OutputIterator >

constexpr OutputIterator daw::copy_n ( Iterator  first, std::size_t  sz, OutputIterator  out_it  )

constexprnoexcept

Definition at line 218 of file daw_vector.h.

copy_ptr_value()

template<typename T >

auto daw::copy_ptr_value

(

T const *const

original

)

Definition at line 359 of file daw_utility.h.

copy_vector()

template<template< class, class > class Vector, typename T , typename A >

constexpr Vector< T, A > daw::copy_vector ( Vector< T, A > const &  container, std::size_t  num_items  )

constexpr

Definition at line 270 of file daw_utility.h.

create_hash_table()

template<typename Key , typename Value >

auto daw::create_hash_table

(

std::initializer_list< std::pair< Key, Value > > const &

values

)

Definition at line 666 of file daw_hash_table.h.

cswap() [1/2]

template<typename T , size_t N>

constexpr void daw::cswap ( std::array< T, N > &  lhs, std::array< T, N > &  rhs  )

constexprnoexcept

Definition at line 91 of file daw_swap.h.

cswap() [2/2]

template<typename T >

constexpr void daw::cswap ( T &&  lhs, T &&  rhs  )

constexprnoexcept

Definition at line 44 of file daw_swap.h.

cxpr_copy()

template<typename Iterator1 , typename Iterator2 , typename OutputIterator >

constexpr OutputIterator daw::cxpr_copy ( Iterator1  first_in, Iterator2 const  last_in, OutputIterator  first_out  )

constexpr

Definition at line 445 of file daw_utility.h.

cxpr_move()

template<typename Iterator1 , typename Iterator2 , typename OutputIterator >

constexpr OutputIterator daw::cxpr_move ( Iterator1  first_in, Iterator2 const  last_in, OutputIterator  first_out  )

constexpr

Definition at line 457 of file daw_utility.h.

data()

template<typename Container >

constexpr auto daw::data ( Container &&  c )

inlineconstexpr

Definition at line 35 of file daw_data_end.h.

data_end()

template<typename Container >

constexpr auto daw::data_end ( Container &&  c )

inlineconstexpr

Definition at line 44 of file daw_data_end.h.

DAW_MAKE_REQ_TRAIT()

daw::DAW_MAKE_REQ_TRAIT	(	can_be_bounded_string	,
		daw::bounded_string{ std::declval< T >() }
	)

decay_copy()

template<class T >

constexpr auto daw::decay_copy ( T &&  v ) -> std::enable_if_t<std::is_convertible_v<T, std::decay_t<T>>, std::decay_t<T>>

constexprnoexcept

Definition at line 203 of file cpp_17.h.

default_contract_failure()

void daw::default_contract_failure ( )

inline

Definition at line 31 of file daw_contract.h.

deleted()

template<typename... >

void daw::deleted ( )

delete

dfs_walk() [1/2]

template<typename T , typename Function , typename ChildOrder = UnorderedWalk>

void daw::dfs_walk	(	daw::graph_t< T > &	graph,
		daw::node_id_t	start_node_id,
		Function &&	func,
		ChildOrder	ord = ChildOrder{ }
	)

Definition at line 553 of file daw_graph_algorithm.h.

dfs_walk() [2/2]

template<typename T , typename Function , typename ChildOrder = UnorderedWalk>

void daw::dfs_walk	(	daw::graph_t< T > const &	graph,
		daw::node_id_t	start_node_id,
		Function &&	func,
		ChildOrder	ord = ChildOrder{ }
	)

Definition at line 546 of file daw_graph_algorithm.h.

distance()

template<typename Iterator >

constexpr ptrdiff_t daw::distance ( Iterator  first, Iterator  second  )

constexprnoexcept

Calculate distance between iterators.

Template Parameters

Iterator

type of Iterator to compare

Parameters

first	first iterator, must be <= second if Iterators are not RandomAccess
second	second iterator, must be >= first if Iterators are not RandomAccess

Returns

a ptrdiff_t of how many steps apart iterators are. If Iterators are RandomAccess it may be <0, otherwise always greater

Definition at line 96 of file cpp_17_iterator.h.

do_not_optimize() [1/2]

template<class T >

DAW_ATTRIB_INLINE void daw::do_not_optimize

(

T const &

value

)

Definition at line 46 of file daw_do_not_optimize.h.

do_not_optimize() [2/2]

template<typename... Values, std::enable_if_t<(sizeof...(Values) !=1), std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE void daw::do_not_optimize

(

Values &&...

values

)

Definition at line 57 of file daw_do_not_optimize.h.

dump()

template<typename... Args>

void daw::dump

(

Args &&...

args

)

Definition at line 78 of file daw_print.h.

empty_range()

constexpr bool daw::empty_range ( Range auto &&  r )

constexpr

Definition at line 198 of file daw_iterator_traits.h.

end_inserter()

template<typename Container >

constexpr auto daw::end_inserter ( Container &  c )

constexpr

Definition at line 60 of file daw_end_inserter.h.

end_inserter_iterator()

template<typename Container >

daw::end_inserter_iterator

(

Container

)

-> end_inserter_iterator< Container >

equal_to()

template<typename T >

constexpr utility_details::EqualToImpl< T > daw::equal_to ( T  value )

inlineconstexpr

Definition at line 114 of file daw_utility.h.

erase()

template<typename T , typename Allocator >

constexpr vector< T, Allocator >::size_type daw::erase ( vector< T, Allocator > &  c, auto const &  v  )

constexpr

Definition at line 1296 of file vector.h.

erase_if()

template<typename T , typename Allocator >

constexpr vector< T, Allocator >::size_type daw::erase_if ( vector< T, Allocator > &  c, auto  pred  )

constexpr

Definition at line 1304 of file vector.h.

exchange()

template<typename T , typename U = T>

DAW_ATTRIB_INLINE constexpr T daw::exchange ( T &  obj, U &&  new_value  )

constexpr

Definition at line 26 of file daw_exchange.h.

expander()

template<typename... Ts>

daw::expander

(

Ts...

)

-> expander< Ts... >

expected_from_code() [1/2]

template<typename Result , typename Function , typename... Args>

expected_t< Result > daw::expected_from_code	(	Function &&	func,
		Args &&...	args
	)

Definition at line 405 of file daw_expected.h.

expected_from_code() [2/2]

template<typename Function , typename... Args>

auto daw::expected_from_code	(	Function &&	func,
		Args &&...	args
	)

Definition at line 417 of file daw_expected.h.

expected_from_exception() [1/2]

template<typename Result >

expected_t< Result > daw::expected_from_exception

(

)

Definition at line 425 of file daw_expected.h.

expected_from_exception() [2/2]

template<typename Result >

expected_t< Result > daw::expected_from_exception

(

std::exception_ptr

ptr

)

Definition at line 431 of file daw_expected.h.

expecting() [1/2]

template<typename Bool >

DAW_ATTRIB_NOINLINE constexpr void daw::expecting ( Bool const &  expected_result )

constexpr

Definition at line 625 of file daw_benchmark.h.

expecting() [2/2]

template<typename T , typename U >

DAW_ATTRIB_NOINLINE constexpr void daw::expecting ( T &&  expected_result, U &&  result  )

constexpr

Definition at line 610 of file daw_benchmark.h.

expecting_exception()

template<typename Exception = std::exception, typename Expression , typename Predicate = benchmark_impl::always_true, std::enable_if_t< std::is_invocable_v< Predicate, Exception >, std::nullptr_t > = nullptr>

DAW_ATTRIB_NOINLINE void daw::expecting_exception	(	Expression &&	expression,
		Predicate &&	pred = Predicate{ }
	)

Definition at line 658 of file daw_benchmark.h.

expecting_message()

template<typename Bool , typename String >

DAW_ATTRIB_NOINLINE constexpr void daw::expecting_message ( Bool &&  expected_result, String &&  message  )

constexpr

Definition at line 633 of file daw_benchmark.h.

extract_from_container()

template<typename T >

constexpr auto daw::extract_from_container ( T &  container )

constexpr

Definition at line 24 of file daw_container_help_ins_ext.h.

find_all_where() [1/2]

template<typename Iterator1 , typename Iterator2 , typename Pred >

std::vector< Iterator1 > daw::find_all_where	(	Iterator1	first,
		Iterator2 const	last,
		Pred	predicate
	)

Definition at line 286 of file daw_utility.h.

find_all_where() [2/2]

template<typename T , typename Pred >

auto daw::find_all_where	(	T const &	values,
		Pred	predicate
	)

Definition at line 293 of file daw_utility.h.

find_iterator() [1/2]

template<typename Iterator , typename Filter >

daw::find_iterator	(	Iterator	,
		Filter
	)		-> find_iterator< Iterator, Iterator, Filter >

find_iterator() [2/2]

template<typename Iterator , typename IteratorLast , typename Filter >

daw::find_iterator	(	Iterator	,
		IteratorLast	,
		Filter
	)		-> find_iterator< Iterator, IteratorLast, Filter >

find_one_iterator()

template<typename Iterator , typename IteratorLast , typename Filter >

daw::find_one_iterator	(	Iterator	,
		IteratorLast	,
		Filter
	)		-> find_one_iterator< Iterator, IteratorLast, Filter >

fixed_array() [1/4]

template<typename Iterator >

daw::fixed_array	(	Iterator	,
		std::size_t
	)		-> fixed_array< typename std::iterator_traits< Iterator >::value_type >

fixed_array() [2/4]

template<typename... Ts>

daw::fixed_array	(	std::in_place_t	,
		Ts...
	)		-> fixed_array< std::common_type_t< Ts... > >

fixed_array() [3/4]

template<typename T , typename... Ts>

daw::fixed_array	(	std::in_place_type_t< T >	,
		Ts...
	)		-> fixed_array< T >

fixed_array() [4/4]

template<typename T >

daw::fixed_array	(	std::size_t	,
		T
	)		-> fixed_array< T >

float_abs()

template<typename Float , std::enable_if_t< std::is_floating_point_v< Float >, std::nullptr_t > = nullptr>

constexpr Float daw::float_abs ( Float  f )

constexpr

Definition at line 28 of file daw_math_impl.h.

fmt_any()

template<typename T >

constexpr decltype(auto) daw::fmt_any ( T &&  v )

constexpr

Definition at line 20 of file daw_formatters.h.

fmt_range() [1/3]

template<Range R>

daw::fmt_range

(

R

)

-> fmt_range< R >

fmt_range() [2/3]

template<Range R, typename CharT >

daw::fmt_range	(	R	,
		CharT const *
	)		-> fmt_range< R, CharT >

fmt_range() [3/3]

template<Range R, typename CharT >

daw::fmt_range	(	R	,
		CharT const *	,
		CharT const *	,
		CharT const *
	)		-> fmt_range< R, CharT >

fmt_tuple() [1/3]

template<typename T >

daw::fmt_tuple

(

T

)

-> fmt_tuple< T >

fmt_tuple() [2/3]

template<typename T , typename CharT >

daw::fmt_tuple	(	T	,
		CharT const *
	)		-> fmt_tuple< T, CharT >

fmt_tuple() [3/3]

template<typename T , typename CharT >

daw::fmt_tuple	(	T	,
		CharT const *	,
		CharT const *	,
		CharT const *
	)		-> fmt_tuple< T, CharT >

fnv1a_hash() [1/6]

template<fnv1a_uint_t N>

constexpr fnv1a_uint_t daw::fnv1a_hash ( char const (&)  ptr[N] )

constexprnoexcept

Definition at line 194 of file daw_fnv1a_hash.h.

fnv1a_hash() [2/6]

constexpr fnv1a_uint_t daw::fnv1a_hash ( char const *  ptr )

constexprnoexcept

Definition at line 159 of file daw_fnv1a_hash.h.

fnv1a_hash() [3/6]

template<typename CharT >

constexpr fnv1a_uint_t daw::fnv1a_hash ( CharT const *  ptr, std::size_t  len  )

constexprnoexcept

Definition at line 171 of file daw_fnv1a_hash.h.

fnv1a_hash() [4/6]

template<typename CharT , size_t Capacity>

constexpr size_t daw::fnv1a_hash ( daw::basic_bounded_string< CharT, Capacity > const &  str )

constexprnoexcept

Definition at line 1339 of file daw_bounded_string.h.

fnv1a_hash() [5/6]

template<typename Integer , std::enable_if_t< std::is_integral_v< Integer >, std::nullptr_t > = nullptr>

constexpr fnv1a_uint_t daw::fnv1a_hash ( Integer  value )

constexprnoexcept

Definition at line 155 of file daw_fnv1a_hash.h.

fnv1a_hash() [6/6]

template<typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>

fnv1a_uint_t daw::fnv1a_hash

(

StringViewLike &&

sv

)

Definition at line 187 of file daw_fnv1a_hash.h.

force_evaluation() [1/2]

template<typename T >

void daw::force_evaluation ( T &  value )

inline

Definition at line 708 of file daw_utility.h.

force_evaluation() [2/2]

template<typename T >

void daw::force_evaluation ( T const &  value )

inline

Definition at line 703 of file daw_utility.h.

forward_as_tuple()

template<typename... Ts>

constexpr tuple< Ts &&... > daw::forward_as_tuple ( Ts &&...  ts )

constexprnoexcept

Definition at line 225 of file daw_tuple.h.

forward_as_tuple2()

template<typename... Ts>

constexpr tuple2< Ts... > daw::forward_as_tuple2 ( Ts &&...  args )

constexpr

Definition at line 170 of file daw_tuple2.h.

forward_counting_iterator()

template<typename ForwardIterator >

daw::forward_counting_iterator

(

ForwardIterator

)

-> forward_counting_iterator< ForwardIterator >

forward_nonrvalue_as_tuple()

template<typename... Ts>

constexpr auto daw::forward_nonrvalue_as_tuple ( Ts &&...  values )

constexpr

Forwards arguments but stores rvalues. This allows use to prevent dangling ref's.

Definition at line 24 of file daw_tuple_forward.h.

forward_nontemp_as_tuple()

template<typename... Ts>

constexpr auto daw::forward_nontemp_as_tuple ( Ts &&...  values )

constexpr

Definition at line 508 of file daw_tuple_helper.h.

forward_nth_pack_element()

template<std::size_t Idx, typename... Ts>

constexpr decltype(auto) daw::forward_nth_pack_element ( Ts &&...  values )

constexpr

Definition at line 38 of file daw_nth_pack_element.h.

function_iterator()

template<typename Function >

daw::function_iterator

(

Function

)

-> function_iterator< Function >

fwd_pack()

template<typename... Ts>

daw::fwd_pack

(

Ts &&

...

)

-> fwd_pack< Ts &&... >

generic_hash() [1/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), std::size_t N>

constexpr auto daw::generic_hash ( char const (&)  ptr[N] )

constexprnoexcept

Definition at line 232 of file daw_generic_hash.h.

generic_hash() [2/7]

template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>

constexpr size_t daw::generic_hash ( daw::basic_bounded_string< CharT, Capacity > const &  str )

constexprnoexcept

Definition at line 1344 of file daw_bounded_string.h.

generic_hash() [3/7]

template<size_t HashSize = sizeof( size_t ), typename CharT , size_t Capacity>

constexpr size_t daw::generic_hash ( daw::basic_bounded_string< CharT, Capacity >  sv )

constexprnoexcept

Definition at line 1372 of file daw_bounded_string.h.

generic_hash() [4/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator , typename IteratorL >

constexpr auto daw::generic_hash ( Iterator  first, IteratorL const  last  )

constexprnoexcept

Definition at line 202 of file daw_generic_hash.h.

generic_hash() [5/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename Iterator >

constexpr auto daw::generic_hash ( Iterator  first, std::size_t const  len  )

constexprnoexcept

Definition at line 213 of file daw_generic_hash.h.

generic_hash() [6/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename StringViewLike , std::enable_if_t< traits_is_sv::is_string_view_like_v< StringViewLike >, std::nullptr_t > = nullptr>

auto daw::generic_hash ( StringViewLike const &&  sv )

noexcept

Definition at line 227 of file daw_generic_hash.h.

generic_hash() [7/7]

template<size_t HashBytes = sizeof( genhash_uint_t ), typename T , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr auto daw::generic_hash ( T const  value )

constexprnoexcept

Definition at line 196 of file daw_generic_hash.h.

get() [1/18]

template<std::size_t Idx, typename... Ts>

constexpr decltype(auto) daw::get ( fwd_pack< Ts... > &&  p )

constexpr

Definition at line 93 of file daw_fwd_pack_apply.h.

get() [2/18]

template<std::size_t Idx, typename... Ts>

constexpr decltype(auto) daw::get ( fwd_pack< Ts... > &  p )

constexpr

Definition at line 98 of file daw_fwd_pack_apply.h.

get() [3/18]

template<std::size_t Idx, typename... Ts>

constexpr decltype(auto) daw::get ( fwd_pack< Ts... > const &  p )

constexpr

Definition at line 104 of file daw_fwd_pack_apply.h.

get() [4/18]

template<typename... Args>

constexpr auto daw::get ( std::tuple< Args... > &  tp, size_t  index  )

constexprnoexcept

Definition at line 54 of file daw_tuple_helper.h.

get() [5/18]

template<typename... Args>

constexpr auto daw::get ( std::tuple< Args... > const &  tp, size_t  index  )

constexprnoexcept

Definition at line 61 of file daw_tuple_helper.h.

get() [6/18]

template<std::size_t Index, typename Ts >

constexpr Ts && daw::get ( tuple2_impl::leaf< Index, Ts, false > &&  tp )

constexpr

Definition at line 143 of file daw_tuple2.h.

get() [7/18]

template<std::size_t Index, typename Ts >

constexpr Ts & daw::get ( tuple2_impl::leaf< Index, Ts, false > &  tp )

constexpr

Definition at line 123 of file daw_tuple2.h.

get() [8/18]

template<std::size_t Index, typename Ts >

constexpr Ts const && daw::get ( tuple2_impl::leaf< Index, Ts, false > const &&  tp )

constexpr

Definition at line 133 of file daw_tuple2.h.

get() [9/18]

template<std::size_t Index, typename Ts >

constexpr Ts const & daw::get ( tuple2_impl::leaf< Index, Ts, false > const &  tp )

constexpr

Definition at line 113 of file daw_tuple2.h.

get() [10/18]

template<std::size_t Index, typename Ts >

constexpr Ts && daw::get ( tuple2_impl::leaf< Index, Ts, true > &&  tp )

constexpr

Definition at line 138 of file daw_tuple2.h.

get() [11/18]

template<std::size_t Index, typename Ts >

constexpr Ts & daw::get ( tuple2_impl::leaf< Index, Ts, true > &  tp )

constexpr

Definition at line 118 of file daw_tuple2.h.

get() [12/18]

template<std::size_t Index, typename Ts >

constexpr Ts const && daw::get ( tuple2_impl::leaf< Index, Ts, true > const &&  tp )

constexpr

Definition at line 128 of file daw_tuple2.h.

get() [13/18]

template<std::size_t Index, typename Ts >

constexpr Ts const & daw::get ( tuple2_impl::leaf< Index, Ts, true > const &  tp )

constexpr

Definition at line 108 of file daw_tuple2.h.

get() [14/18]

template<std::size_t N, typename... Ts>

constexpr decltype(auto) daw::get ( tuple< Ts... > &&  tp )

constexpr

Definition at line 220 of file daw_tuple.h.

get() [15/18]

template<std::size_t N, typename... Ts>

constexpr decltype(auto) daw::get ( tuple< Ts... > &  tp )

constexpr

Definition at line 215 of file daw_tuple.h.

get() [16/18]

template<std::size_t N, typename... Ts>

constexpr decltype(auto) daw::get ( tuple< Ts... > const &  tp )

constexpr

Definition at line 210 of file daw_tuple.h.

get() [17/18]

template<size_t N, typename... T>

constexpr decltype(auto) daw::get ( zip_iterator< T... > &  zi )

constexprnoexcept

Definition at line 183 of file daw_zipiter.h.

get() [18/18]

template<size_t N, typename... T>

constexpr decltype(auto) daw::get ( zip_iterator< T... > const &  zi )

constexprnoexcept

Definition at line 188 of file daw_zipiter.h.

get_bit() [1/4]

template<unsigned N>

constexpr UInt16 daw::get_bit ( UInt16  value )

inlineconstexpr

Definition at line 2913 of file daw_uint_types.h.

get_bit() [2/4]

template<unsigned N>

constexpr UInt32 daw::get_bit ( UInt32  value )

inlineconstexpr

Definition at line 2900 of file daw_uint_types.h.

get_bit() [3/4]

template<unsigned N>

constexpr UInt64 daw::get_bit ( UInt64  value )

inlineconstexpr

Definition at line 2887 of file daw_uint_types.h.

get_bit() [4/4]

template<unsigned N>

constexpr UInt8 daw::get_bit ( UInt8  value )

inlineconstexpr

Definition at line 2925 of file daw_uint_types.h.

get_bits()

template<typename Integer , typename Bit , typename... Bits>

constexpr Integer daw::get_bits ( Integer  i, Bit  b, Bits...  bs  )

constexprnoexcept

get value with all bits but those specified masked out

Definition at line 96 of file daw_bit.h.

get_buffer()

template<typename T , std::size_t Alignment = alignof( T )>

T * daw::get_buffer ( std::size_t  count )

inlinenoexcept

aligned_alloc is not in clang-cl 13 with vs2022

Definition at line 937 of file daw_utility.h.

get_left_mask()

template<typename T >

constexpr T daw::get_left_mask ( size_t  left_zero_bits )

constexprnoexcept

Definition at line 24 of file daw_bit.h.

get_nt()

template<std::size_t Idx, typename Variant >

constexpr decltype(auto) daw::get_nt ( Variant &&  var )

constexpr

Definition at line 54 of file daw_visit.h.

get_right_mask()

template<typename T >

constexpr T daw::get_right_mask ( size_t  right_zero_bits )

constexprnoexcept

Definition at line 38 of file daw_bit.h.

hex() [1/7]

template<typename OutputIterator >

constexpr OutputIterator daw::hex ( char  c, OutputIterator  it_out  )

constexprnoexcept

Definition at line 487 of file daw_utility.h.

hex() [2/7]

template<size_t N, typename OutputIterator >

constexpr OutputIterator daw::hex ( char const (&)  str[N], OutputIterator  first_out  )

constexprnoexcept

Definition at line 558 of file daw_utility.h.

hex() [3/7]

template<typename OutputIterator >

constexpr OutputIterator daw::hex ( char const *  str, std::size_t  len, OutputIterator  first_out  )

constexprnoexcept

Definition at line 549 of file daw_utility.h.

hex() [4/7]

template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>

constexpr OutputIterator daw::hex ( ForwardIterator1  first_in, ForwardIterator2 const  last_in, OutputIterator  first_out  )

constexprnoexcept

Definition at line 538 of file daw_utility.h.

hex() [5/7]

template<typename ForwardIterator1 , typename ForwardIterator2 , typename OutputIterator , std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< ForwardIterator1 >::value_type >, std::nullptr_t > = nullptr>

OutputIterator daw::hex ( ForwardIterator1  first_in, ForwardIterator2 const  last_in, OutputIterator  first_out  )

noexcept

Definition at line 568 of file daw_utility.h.

hex() [6/7]

template<typename T , typename OutputIterator , std::enable_if_t< std::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr OutputIterator daw::hex ( T const &  val, OutputIterator  it_out  )

constexprnoexcept

Definition at line 510 of file daw_utility.h.

hex() [7/7]

template<typename T , typename OutputIterator , std::enable_if_t< not std::is_integral_v< T >, std::nullptr_t > = nullptr>

OutputIterator daw::hex ( T const &  val, OutputIterator  it_out  )

noexcept

Definition at line 521 of file daw_utility.h.

hex_lc()

template<typename OutputIterator >

constexpr OutputIterator daw::hex_lc ( char  c, OutputIterator  it_out  )

constexprnoexcept

Definition at line 499 of file daw_utility.h.

ibegin() [1/3]

template<typename T >

constexpr auto daw::ibegin ( T &&  container )

constexprnoexcept

Definition at line 208 of file daw_indexed_iterator.h.

ibegin() [2/3]

template<typename T , size_t N>

constexpr auto daw::ibegin ( T const (&)  container[N] )

constexprnoexcept

Definition at line 251 of file daw_indexed_iterator.h.

ibegin() [3/3]

template<typename T , size_t N>

constexpr auto daw::ibegin ( T(&)  container[N] )

constexprnoexcept

Definition at line 246 of file daw_indexed_iterator.h.

iend() [1/3]

template<typename T >

constexpr auto daw::iend ( T &&  container )

constexprnoexcept

Definition at line 226 of file daw_indexed_iterator.h.

iend() [2/3]

template<typename T , size_t N>

constexpr auto daw::iend ( T const (&)  container[N] )

constexprnoexcept

Definition at line 271 of file daw_indexed_iterator.h.

iend() [3/3]

template<typename T , size_t N>

constexpr auto daw::iend ( T(&)  container[N] )

constexprnoexcept

Definition at line 266 of file daw_indexed_iterator.h.

in_range() [1/2]

template<typename R , typename T , std::enable_if_t< daw::is_integral_v< R > and daw::is_integral_v< T >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::in_range ( T  t )

constexprnoexcept

Definition at line 91 of file daw_int_cmp.h.

in_range() [2/2]

template<typename Value , typename LowerBound , typename UpperBound >

constexpr bool daw::in_range ( Value &&  value, LowerBound &&  lower, UpperBound &&  upper  )

constexprnoexcept

Checks if value is in the range [lower, upper)

Definition at line 810 of file daw_utility.h.

index_of()

template<typename Container , typename Item >

constexpr auto daw::index_of ( Container const &  container, Item const &  item  )

constexprnoexcept

Definition at line 386 of file daw_utility.h.

InputIterator()

template<typename Iterator >

daw::InputIterator

(

Iterator

)

-> InputIterator< typename std::iterator_traits< Iterator >::value_type >

InputRange() [1/2]

template<typename Container >

daw::InputRange

(

Container

)

-> InputRange< std::remove_reference_t< decltype(*std::begin(std::declval< Container >()))> >

InputRange() [2/2]

template<typename Iterator >

daw::InputRange	(	Iterator	,
		Iterator
	)		-> InputRange< typename std::iterator_traits< Iterator >::value_type >

insert_into_container()

template<typename Container , typename Allocator , typename Pointer >

constexpr void daw::insert_into_container ( Container &  vec, Pointer *  buff, Allocator  alloc, std::size_t  capacity, std::size_t  size  )

constexpr

Definition at line 29 of file daw_container_help_ins_ext.h.

inserter()

template<typename Container >

constexpr auto daw::inserter ( Container &  c )

constexpr

Definition at line 58 of file daw_inserter.h.

invoke() [1/2]

template<typename F , typename... Args, std::enable_if_t< sizeof...(Args) !=1 or((not is_reference_wrapper_v< Args >) and ...), std::nullptr_t > = nullptr>

constexpr decltype(auto) daw::invoke ( F &&  f, Args &&...  args  )

constexprnoexcept

Definition at line 106 of file daw_apply.h.

invoke() [2/2]

template<typename F , typename Arg , typename... Args>

constexpr decltype(auto) daw::invoke ( F &&  f, std::reference_wrapper< Arg >  arg, std::reference_wrapper< Args >...  args  )

constexprnoexcept

Definition at line 113 of file daw_apply.h.

iota_iterator() [1/2]

daw::iota_iterator

(

)

-> iota_iterator< int >

iota_iterator() [2/2]

template<typename T , typename... Step>

daw::iota_iterator	(	T	,
		Step...
	)		-> iota_iterator< T >

iota_range() [1/2]

daw::iota_range

(

)

-> iota_range< int >

iota_range() [2/2]

template<typename T , typename... EndStep>

daw::iota_range	(	T	,
		EndStep...
	)		-> iota_range< T >

is_space()

constexpr bool daw::is_space ( char  chr )

inlineconstexprnoexcept

Definition at line 280 of file daw_utility.h.

iter_last()

template<typename R >

constexpr auto daw::iter_last ( R &&  r )

constexpr

Definition at line 216 of file daw_iterator_traits.h.

iter_swap()

template<typename ForwardIterator1 , typename ForwardIterator2 >

constexpr void daw::iter_swap ( ForwardIterator1  lhs, ForwardIterator2  rhs  )

constexprnoexcept

Definition at line 69 of file daw_swap.h.

iter_view() [1/4]

template<typename Container >

daw::iter_view

(

Container

)

-> iter_view< typename Container::iterator >

iter_view() [2/4]

template<typename ForwardIterator , typename Last >

daw::iter_view	(	ForwardIterator	,
		Last
	)		-> iter_view< ForwardIterator, Last >

iter_view() [3/4]

template<typename T , std::size_t N>

daw::iter_view

(

T(&&)

[N]

)

-> iter_view< T * >

iter_view() [4/4]

template<typename T , std::size_t N>

daw::iter_view

(

T(&)

[N]

)

-> iter_view< T * >

make_array() [1/2]

template<typename T = make_array_impl::unspecified_type, typename... Args, std::enable_if_t< not std::is_same_v< T, void >, std::nullptr_t > = nullptr>

constexpr auto daw::make_array ( Args &&...  args )

constexpr

Definition at line 72 of file daw_array.h.

make_array() [2/2]

template<typename T , size_t N>

constexpr auto daw::make_array ( T const (&&)  arry[N] )

constexpr

Definition at line 92 of file daw_array.h.

make_bit_iterator()

template<typename Iterator >

constexpr auto daw::make_bit_iterator ( Iterator &&  it )

constexpr

Create a bit_iterator with supplied bit.

Definition at line 74 of file daw_bit_iterator.h.

make_bit_stream()

template<typename BitQueueLSB = bit_queue_source_native_endian, typename InputIteratorF , typename InputIteratorL >

constexpr auto daw::make_bit_stream ( InputIteratorF  first, InputIteratorL  last  )

constexprnoexcept

Definition at line 148 of file daw_bit_stream.h.

make_bounded_hash_map()

template<typename Key , typename Value , typename Hash = std::hash<Key>, size_t N>

DAW_CONSTEVAL auto daw::make_bounded_hash_map

(

std::pair< Key, Value > const (&)

items[N]

)

Definition at line 550 of file daw_bounded_hash_map.h.

make_bounded_hash_set()

template<typename Key , typename Hash = std::hash<Key>, size_t N>

constexpr auto daw::make_bounded_hash_set ( Key const (&)  items[N] )

constexprnoexcept

Definition at line 469 of file daw_bounded_hash_set.h.

make_bounded_string() [1/2]

template<size_t Capacity = 100, typename CharT , size_t N>

constexpr daw::basic_bounded_string< CharT, Capacity > daw::make_bounded_string ( CharT const (&)  str[N] )

constexpr

Definition at line 785 of file daw_bounded_string.h.

make_bounded_string() [2/2]

template<size_t Capacity = 100, typename Container >

constexpr auto daw::make_bounded_string ( Container const &  v ) -> basic_bounded_string<typename Container::value_type, Capacity>

constexprnoexcept

Definition at line 777 of file daw_bounded_string.h.

make_bounded_string_it() [1/2]

template<size_t Capacity = 100, typename CharT >

constexpr auto daw::make_bounded_string_it ( CharT const *  first, CharT const *  last  )

constexprnoexcept

Definition at line 760 of file daw_bounded_string.h.

make_bounded_string_it() [2/2]

template<size_t Capacity = 100, typename Iterator , typename CharT = DAW_TYPEOF( *std::declval<Iterator>( ) )>

constexpr auto daw::make_bounded_string_it ( Iterator  first, Iterator  last  )

constexprnoexcept

Definition at line 768 of file daw_bounded_string.h.

make_callable() [1/2]

template<typename Function , std::enable_if_t< not std::is_function_v< std::remove_reference_t< Function > >, std::nullptr_t > = nullptr>

constexpr decltype(auto) daw::make_callable ( Function &&  func )

constexprnoexcept

Definition at line 161 of file daw_function.h.

make_callable() [2/2]

template<typename Function , std::enable_if_t< std::is_function_v< Function >, std::nullptr_t > = nullptr>

constexpr auto daw::make_callable ( Function *  func )

constexprnoexcept

Definition at line 196 of file daw_function.h.

make_checked_function()

template<typename Result , typename... Exceptions, typename Function >

constexpr checked_function_t< Function, Result, Exceptions... > daw::make_checked_function ( Function &&  func )

constexprnoexcept

Definition at line 413 of file daw_checked_expected.h.

make_checked_iterator_proxy()

template<typename IteratorFirst , typename IteratorLast >

auto daw::make_checked_iterator_proxy	(	IteratorFirst	first,
		IteratorLast	last,
		bool	CheckIncrement = true,
		bool	CheckDecrement = true,
		bool	CheckDereference = true
	)

Definition at line 173 of file daw_checked_iterator_proxy.h.

make_circular_iterator() [1/2]

template<typename Container >

constexpr auto daw::make_circular_iterator ( Container &  container )

constexprnoexcept

Definition at line 235 of file daw_circular_iterator.h.

make_circular_iterator() [2/2]

template<typename Container , typename Iterator >

constexpr auto daw::make_circular_iterator ( Container &  container, Iterator  it  )

constexprnoexcept

Definition at line 240 of file daw_circular_iterator.h.

make_const_random_iterator()

template<typename T >

constexpr auto daw::make_const_random_iterator ( T *const  ptr )

constexprnoexcept

Definition at line 146 of file daw_random_iterator.h.

make_copiable_unique_ptr()

template<typename T , typename... Args>

copiable_unique_ptr< T > daw::make_copiable_unique_ptr ( Args &&...  args )

noexcept

Definition at line 134 of file daw_copiable_unique_ptr.h.

make_fixed_lookup()

template<typename Value , size_t HashSize = sizeof( size_t ), typename... Keys>

constexpr auto daw::make_fixed_lookup ( Keys &&...  keys )

constexprnoexcept

Definition at line 197 of file daw_fixed_lookup.h.

make_formatter()

template<size_t N>

constexpr auto daw::make_formatter ( char const (&)  str[N] )

constexpr

Definition at line 110 of file format.h.

make_from_tuple2()

template<class T , class Tuple >

constexpr T daw::make_from_tuple2 ( Tuple &&  t )

constexpr

Definition at line 491 of file daw_tuple_helper.h.

make_function() [1/6]

template<typename L >

constexpr function_traits_t< L > daw::make_function ( L  l )

constexprnoexcept

Definition at line 199 of file daw_utility.h.

make_function() [2/6]

template<typename ReturnType , typename... Args>

std::function< ReturnType(Args...)> daw::make_function

(

ReturnType(*)(Args...)

p

)

Definition at line 218 of file daw_utility.h.

make_function() [3/6]

template<typename ReturnType , typename... Args>

std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> daw::make_function

(

ReturnType(*)(Args...)

p

)

Definition at line 242 of file daw_utility.h.

make_function() [4/6]

template<typename ReturnType , typename... Args, typename ClassType >

std::function< ReturnType(Args...)> daw::make_function

(

ReturnType(ClassType::*)(Args...)

p

)

Definition at line 225 of file daw_utility.h.

make_function() [5/6]

template<typename ReturnType , typename... Args, typename ClassType >

std::function< daw::traits::root_type_t< ReturnType >(daw::traits::root_type_t< Args >...)> daw::make_function

(

ReturnType(ClassType::*)(Args...)

p

)

Definition at line 250 of file daw_utility.h.

make_function() [6/6]

template<typename ReturnType , typename... Args, class T >

auto daw::make_function

(

T &&

t

)

-> std::function< decltype( ReturnType( t( std::declval<Args>( )... ) ) )( Args... )>

Definition at line 210 of file daw_utility.h.

make_function_iterator()

template<typename Function >

constexpr auto daw::make_function_iterator ( Function &&  func )

constexpr

Create a function_iterator with supplied function.

Definition at line 65 of file daw_function_iterator.h.

make_function_table()

template<typename R = void, typename Function , typename... Functions>

constexpr function_table_t< R, Function, Functions... > daw::make_function_table ( Function  fn, Functions...  fns  )

constexpr

Definition at line 151 of file daw_function_table.h.

make_initializer_list()

template<typename Arg , typename... Args>

auto daw::make_initializer_list	(	Arg &&	arg,
		Args &&...	args
	)

Definition at line 368 of file daw_utility.h.

make_mask()

template<typename Bit , typename... Bits>

constexpr auto daw::make_mask ( Bit  bit, Bits...  bits  )

constexprnoexcept

Definition at line 51 of file daw_bit.h.

make_move_iterator()

template<typename Iterator >

constexpr std::move_iterator< Iterator > daw::make_move_iterator ( Iterator &&  i )

constexpr

Definition at line 16 of file daw_iterator.h.

make_optional_poly()

template<typename T , typename... Args>

auto daw::make_optional_poly

(

Args &&...

args

)

Definition at line 175 of file daw_optional_poly.h.

make_output_stream_iterator()

template<typename OutputStream >

constexpr function_iterator< osi_impl::osi_callable< OutputStream > > daw::make_output_stream_iterator ( OutputStream &  strm )

constexpr

Definition at line 37 of file daw_output_stream_iterator.h.

make_perfect_hash_table()

template<typename Hasher , typename Key , typename Value , size_t N>

constexpr auto daw::make_perfect_hash_table ( std::pair< Key, Value > const (&)  data[N] )

constexpr

Definition at line 329 of file daw_min_perfect_hash.h.

make_random_data()

template<typename IntType , typename Result = std::vector<IntType>>

Result daw::make_random_data ( std::size_t  count, IntType  a = lowest_value<IntType>, IntType  b = max_value<IntType>  )

inline

Definition at line 94 of file daw_random.h.

make_random_iterator()

template<typename T >

constexpr auto daw::make_random_iterator ( T *const  ptr )

constexprnoexcept

Definition at line 140 of file daw_random_iterator.h.

make_range()

template<typename Iterator >

constexpr auto daw::make_range ( Iterator  first, Iterator  last  )

constexprnoexcept

Definition at line 578 of file daw_utility.h.

make_rc_ptr() [1/2]

template<typename T , typename... Args>

DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > daw::make_rc_ptr

(

Args &&...

args

)

Definition at line 424 of file daw_ref_counted_pointer.h.

make_rc_ptr() [2/2]

template<typename T >

DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > daw::make_rc_ptr

(

std::size_t

size

)

Definition at line 435 of file daw_ref_counted_pointer.h.

make_rc_ptr_for_overwrite() [1/2]

template<typename T , typename... Args>

DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_single< T > daw::make_rc_ptr_for_overwrite ( Args &&  ... )

delete

make_rc_ptr_for_overwrite() [2/2]

template<typename T >

DAW_CPP20_CX_ALLOC rc_ptr_impl::make_rc_ptr_array< T > daw::make_rc_ptr_for_overwrite

(

std::size_t

size

)

Definition at line 446 of file daw_ref_counted_pointer.h.

make_reverse_iterator()

template<typename Iterator >

constexpr reverse_iterator< Iterator > daw::make_reverse_iterator ( Iterator  i )

constexpr

Definition at line 180 of file daw_reverse_iterator.h.

make_reverse_topological_sorted_range()

template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>

auto daw::make_reverse_topological_sorted_range	(	Graph &&	g,
		Compare	c = Compare{ }
	)

Definition at line 453 of file daw_graph_algorithm.h.

make_root_function() [1/2]

template<typename L >

constexpr auto daw::make_root_function ( L  l )

constexprnoexcept

Definition at line 204 of file daw_utility.h.

make_root_function() [2/2]

template<typename ReturnType , typename... Args, class T >

auto daw::make_root_function

(

T &&

t

)

-> std::function<decltype( daw::traits::root_type_t<ReturnType>( t( std::declval<daw::traits::root_type_t<Args>>( )... ) ) )( Args... )>

Definition at line 232 of file daw_utility.h.

make_safe_string() [1/2]

template<typename SanitizeFunction , typename charT , typename traits = std::char_traits<charT>, typename Alloc = std::allocator<charT>>

auto daw::make_safe_string	(	charT const *const	unsafe_cstring,
		SanitizeFunction &&	sanitize_function
	)

Definition at line 92 of file daw_safe_string.h.

make_safe_string() [2/2]

template<typename SanitizeFunction , typename charT , typename traits , typename Alloc >

auto daw::make_safe_string	(	std::basic_string< charT, traits, Alloc >	unsafe_string,
		SanitizeFunction &&	sanitize_function
	)

Definition at line 82 of file daw_safe_string.h.

make_sorted_insert_iterator() [1/3]

template<typename... Args, typename Compare = std::less<>>

auto daw::make_sorted_insert_iterator	(	std::deque< Args... > &	c,
		Compare	compare = Compare{ }
	)

Definition at line 74 of file daw_sorted_insert_iterator.h.

make_sorted_insert_iterator() [2/3]

template<typename... Args, typename Compare = std::less<>>

decltype(auto) daw::make_sorted_insert_iterator	(	std::list< Args... > &	c,
		Compare	compare = Compare{ }
	)

Definition at line 82 of file daw_sorted_insert_iterator.h.

make_sorted_insert_iterator() [3/3]

template<typename... Args, typename Compare = std::less<>>

auto daw::make_sorted_insert_iterator	(	std::vector< Args... > &	c,
		Compare	compare = Compare{ }
	)

Definition at line 66 of file daw_sorted_insert_iterator.h.

make_split_it() [1/2]

template<typename CharT , typename Traits , typename Allocator >

constexpr auto daw::make_split_it ( std::basic_string< CharT, Traits, Allocator > &  str, CharT  divider  )

constexprnoexcept

Definition at line 588 of file daw_split_iterator.h.

make_split_it() [2/2]

template<typename String , typename Splitter , daw::required< impl::is_splitter_v< Splitter, String > > = nullptr>

constexpr auto daw::make_split_it ( String &  sv, Splitter &&  splitter  )

constexprnoexcept

Definition at line 579 of file daw_split_iterator.h.

make_std_function()

template<typename ReturnType , typename... Args, typename ClassType >

std::function< ReturnType(Args...)> daw::make_std_function

(

ReturnType(ClassType::*)(Args...)

p

)

Definition at line 258 of file daw_utility.h.

make_string_array()

template<typename... Ts>

std::array< std::string, sizeof...(Ts)> daw::make_string_array

(

Ts &&...

t

)

Definition at line 98 of file daw_array.h.

make_topological_sorted_range()

template<typename Graph , typename Compare = daw::graph_alg_impl::NoSort>

auto daw::make_topological_sorted_range	(	Graph &&	g,
		Compare	c = Compare{ }
	)

Definition at line 413 of file daw_graph_algorithm.h.

make_tuple()

template<typename... Ts>

constexpr tuple< make_tuple_details::unwrap_decay_t< Ts >... > daw::make_tuple ( Ts &&...  args )

constexpr

Definition at line 252 of file daw_tuple.h.

make_unique() [1/2]

template<typename T , typename... Args>

DAW_CPP20_CX_ALLOC auto daw::make_unique

(

Args &&...

args

)

-> std::enable_if_t<not std::is_array_v<T>, unique_ptr<T>>

Definition at line 394 of file daw_unique_ptr.h.

make_unique() [2/2]

template<typename T >

DAW_CPP20_CX_ALLOC auto daw::make_unique

(

std::size_t

count

)

-> std::enable_if_t<std::is_array_v<T>, unique_ptr<T>>

Definition at line 410 of file daw_unique_ptr.h.

make_unique_array()

template<typename T , typename... Elements>

DAW_CPP20_CX_ALLOC auto daw::make_unique_array

(

Elements &&...

elements

)

-> std::enable_if_t<std::is_array_v<T>, unique_ptr<T>>

Definition at line 420 of file daw_unique_ptr.h.

make_unique_for_overwrite()

template<typename T >

DAW_CPP20_CX_ALLOC auto daw::make_unique_for_overwrite

(

)

-> std::enable_if_t<not std::is_array_v<T>, unique_ptr<T>>

Definition at line 404 of file daw_unique_ptr.h.

make_void_function()

template<typename Function >

constexpr auto daw::make_void_function ( Function &&  func )

constexprnoexcept

Definition at line 288 of file daw_traits_impl.h.

make_zipcontainer()

template<typename... Containers>

zip_container< Containers... > daw::make_zipcontainer

(

Containers &&...

args

)

Definition at line 62 of file daw_zipcontainer.h.

mask_lsb()

template<typename T >

constexpr T daw::mask_lsb ( size_t  bit_count )

constexprnoexcept

Definition at line 43 of file daw_bit.h.

mask_msb()

template<typename T >

constexpr T daw::mask_msb ( size_t  bit_count )

constexprnoexcept

Definition at line 29 of file daw_bit.h.

max()

template<typename T , typename... Ts>

constexpr auto() daw::max ( T const &  val1, Ts const &...  vs  )

constexprnoexcept

Definition at line 36 of file daw_math_impl.h.

max_comp()

template<typename T , typename Compare = math_impl::less>

constexpr decltype(auto) daw::max_comp ( T &&  lhs, T &&  rhs, Compare &&  comp = Compare{ }  )

constexpr

Definition at line 67 of file daw_math_impl.h.

min()

template<typename T , typename... Ts>

constexpr auto() daw::min ( T const &  val1, Ts const &...  vs  )

constexprnoexcept

Definition at line 76 of file daw_math_impl.h.

min_comp()

template<typename T , typename Compare = math_impl::less>

constexpr decltype(auto) daw::min_comp ( T &&  lhs, T &&  rhs, Compare &&  comp = Compare{ }  )

constexpr

Definition at line 58 of file daw_math_impl.h.

move()

template<typename T >

constexpr daw::traits::remove_reference_t< T > && daw::move ( T &&  value )

inlineconstexprnoexcept

Convert a value to an rvalue.

Parameters

value

A thing of arbitrary type.

Returns

The parameter cast to an rvalue-reference to allow moving it.

Definition at line 26 of file daw_move.h.

move_n()

template<typename Iterator , typename OutputIterator >

constexpr OutputIterator daw::move_n ( Iterator  first, std::size_t  sz, OutputIterator  out_it  )

constexprnoexcept

Definition at line 212 of file daw_vector.h.

move_only()

template<typename T >

daw::move_only

(

T

)

-> move_only< T >

mst()

template<typename T , typename Compare = daw::graph_alg_impl::NoSort>

void daw::mst	(	daw::graph_t< T > &	graph,
		Compare	= Compare{ }
	)

Definition at line 198 of file daw_graph_algorithm.h.

mutable_capture()

template<typename T >

daw::mutable_capture

(

T

)

-> mutable_capture< T >

narrow_cast()

template<typename Integer , typename... Ts, typename T >

constexpr Integer daw::narrow_cast ( T  value )

constexpr

Definition at line 869 of file daw_utility.h.

network_to_host_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr T daw::network_to_host_endian ( T  value )

constexprnoexcept

Definition at line 134 of file daw_endian.h.

next()

template<typename Iterator >

constexpr Iterator daw::next ( Iterator  it, ptrdiff_t  n = 1  )

constexprnoexcept

Move iterator forward n steps, if n < 0 it is only defined for types that are Bidirectional.

Template Parameters

Iterator

Type of iterator to move forward

Parameters

it	Iterator to advance
n	how far to move forward

Returns

The resulting iterator of advancing it n steps

Definition at line 124 of file cpp_17_iterator.h.

none_of_f()

template<typename... Ts>

constexpr auto daw::none_of_f ( Ts &&...  needles )

constexprnoexcept

Definition at line 83 of file daw_view_tags.h.

Not()

template<typename Function >

constexpr utility_details::NotImpl< Function > daw::Not ( Function  func )

inlineconstexpr

Definition at line 154 of file daw_utility.h.

not_fn() [1/2]

template<typename Function >

constexpr auto daw::not_fn ( )

constexpr

Definition at line 93 of file cpp_17.h.

not_fn() [2/2]

template<typename Function >

constexpr auto daw::not_fn ( Function &&  func )

constexpr

Definition at line 87 of file cpp_17.h.

not_null() [1/4]

template<typename Pointer >

daw::not_null	(	never_null_t	,
		not_null< Pointer >
	)		-> not_null< Pointer >

not_null() [2/4]

template<typename Pointer >

daw::not_null	(	never_null_t	,
		Pointer
	)		-> not_null< Pointer >

not_null() [3/4]

template<typename Pointer >

daw::not_null

(

not_null< Pointer >

)

-> not_null< Pointer >

not_null() [4/4]

template<typename Pointer >

daw::not_null

(

Pointer

)

-> not_null< Pointer >

nsc_and()

template<typename Bool , typename... Bools>

DAW_ATTRIB_INLINE constexpr bool daw::nsc_and ( Bool  lhs, Bools...  rhs  )

constexprnoexcept

Explicitly do a non-short circuiting logical and with bitwise and.

Definition at line 17 of file daw_logic.h.

nsc_or()

template<typename Bool , typename... Bools>

DAW_ATTRIB_INLINE constexpr bool daw::nsc_or ( Bool  lhs, Bools...  rhs  )

constexprnoexcept

Explicitly do a non-short circuiting logical or with bitwise or.

Definition at line 24 of file daw_logic.h.

nth_pack_element()

template<std::size_t Idx, typename... Ts>

constexpr auto daw::nth_pack_element ( Ts &&...  values )

constexpr

Definition at line 31 of file daw_nth_pack_element.h.

observer_ptr()

template<typename P >

daw::observer_ptr

(

P *

)

-> observer_ptr< P >

offset_of()

template<typename Obj , typename T >

constexpr std::size_t daw::offset_of ( T Obj::*  Mem )

constexpr

Definition at line 17 of file daw_cx_offset_of.h.

on_exit_success()

template<typename Handler >

daw::on_exit_success

(

Handler

)

-> on_exit_success< Handler >

on_scope_exit()

template<typename FunctionType >

DAW_ATTRIB_INLINE constexpr ScopeGuard< FunctionType > daw::on_scope_exit ( FunctionType  f )

constexprnoexcept

Definition at line 88 of file daw_scope_guard.h.

operator!() [1/4]

constexpr bool daw::operator! ( UInt16  value )

constexpr

Definition at line 2406 of file daw_uint_types.h.

operator!() [2/4]

constexpr bool daw::operator! ( UInt32  value )

constexpr

Definition at line 2122 of file daw_uint_types.h.

operator!() [3/4]

constexpr bool daw::operator! ( UInt64  value )

constexpr

Definition at line 1738 of file daw_uint_types.h.

operator!() [4/4]

constexpr bool daw::operator! ( UInt8  value )

constexpr

Definition at line 2603 of file daw_uint_types.h.

operator!=() [1/51]

template<typename T , typename U , size_t N>

constexpr bool daw::operator!= ( array< T, N > const &  lhs, array< U, N > const &  rhs  )

constexpr

Definition at line 109 of file daw_bounded_array.h.

operator!=() [2/51]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator!= ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 801 of file daw_bounded_string.h.

operator!=() [3/51]

template<typename Key , typename Value >

constexpr bool daw::operator!= ( bounded_hash_map_iterator< Key, Value > const &  lhs, bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 276 of file daw_bounded_hash_map.h.

operator!=() [4/51]

template<typename Key , typename Value >

constexpr bool daw::operator!= ( bounded_hash_map_iterator< Key, Value > const &  lhs, const_bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 290 of file daw_bounded_hash_map.h.

operator!=() [5/51]

template<typename Key >

constexpr bool daw::operator!= ( bounded_hash_set_iterator< Key > const &  lhs, bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 254 of file daw_bounded_hash_set.h.

operator!=() [6/51]

template<typename Key >

constexpr bool daw::operator!= ( bounded_hash_set_iterator< Key > const &  lhs, const_bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 268 of file daw_bounded_hash_set.h.

operator!=() [7/51]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator!= ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1203 of file daw_bounded_string.h.

operator!=() [8/51]

template<typename Key , typename Value >

constexpr bool daw::operator!= ( const_bounded_hash_map_iterator< Key, Value > const &  lhs, bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 297 of file daw_bounded_hash_map.h.

operator!=() [9/51]

template<typename Key , typename Value >

constexpr bool daw::operator!= ( const_bounded_hash_map_iterator< Key, Value > const &  lhs, const_bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 283 of file daw_bounded_hash_map.h.

operator!=() [10/51]

template<typename Key >

constexpr bool daw::operator!= ( const_bounded_hash_set_iterator< Key > const &  lhs, bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 275 of file daw_bounded_hash_set.h.

operator!=() [11/51]

template<typename Key >

constexpr bool daw::operator!= ( const_bounded_hash_set_iterator< Key > const &  lhs, const_bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 261 of file daw_bounded_hash_set.h.

operator!=() [12/51]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator!= ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 160 of file daw_copiable_unique_ptr.h.

operator!=() [13/51]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator!= ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 167 of file daw_copiable_unique_ptr.h.

operator!=() [14/51]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1152 of file daw_bounded_string.h.

operator!=() [15/51]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 851 of file daw_bounded_string.h.

operator!=() [16/51]

template<typename CharT , size_t Capacity>

bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 950 of file daw_bounded_string.h.

operator!=() [17/51]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator!= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1047 of file daw_bounded_string.h.

operator!=() [18/51]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 286 of file daw_not_null.h.

operator!=() [19/51]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 293 of file daw_not_null.h.

operator!=() [20/51]

template<typename T >

bool daw::operator!=	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 194 of file daw_optional_poly.h.

operator!=() [21/51]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator!= ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 901 of file daw_bounded_string.h.

operator!=() [22/51]

template<typename T , typename U >

bool daw::operator!=	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 262 of file daw_hash_table.h.

operator!=() [23/51]

template<typename T , typename U >

bool daw::operator!=	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 129 of file deprecated/daw_heap_value.h.

operator!=() [24/51]

template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator!= ( indexed_iterator< T > const &  , indexed_iterator< U > const &    )

constexprnoexcept

Definition at line 310 of file daw_indexed_iterator.h.

operator!=() [25/51]

template<typename T >

constexpr bool daw::operator!= ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 301 of file daw_indexed_iterator.h.

operator!=() [26/51]

template<typename T , typename U >

constexpr bool daw::operator!= ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 187 of file daw_natural.h.

operator!=() [27/51]

constexpr bool daw::operator!= ( node_id_t const &  lhs, node_id_t const &  rhs  )

constexprnoexcept

Definition at line 77 of file daw_bounded_graph.h.

operator!=() [28/51]

template<typename T , typename U >

constexpr bool daw::operator!= ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 264 of file daw_optional.h.

operator!=() [29/51]

template<typename T >

constexpr bool daw::operator!= ( optional< T > const &  opt, std::nullopt_t    )

constexprnoexcept

Definition at line 329 of file daw_optional.h.

operator!=() [30/51]

template<typename T , typename U >

constexpr bool daw::operator!= ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 398 of file daw_optional.h.

operator!=() [31/51]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator!= ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 299 of file daw_not_null.h.

operator!=() [32/51]

template<typename T >

bool daw::operator!=	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 46 of file daw_reference.h.

operator!=() [33/51]

template<typename CharT >

constexpr bool daw::operator!= ( repeat_n_char_iterator< CharT > const &  lhs, repeat_n_char_iterator< CharT > const &  rhs  )

constexprnoexcept

Definition at line 119 of file daw_repeat_n_char_iterator.h.

operator!=() [34/51]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator!= ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 150 of file daw_reverse_iterator.h.

operator!=() [35/51]

template<typename Iterator >

constexpr bool daw::operator!= ( splitter_range_t< Iterator > const &  lhs, splitter_range_t< Iterator > const &  rhs  )

constexprnoexcept

Definition at line 87 of file daw_split_iterator.h.

operator!=() [36/51]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator!= ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 996 of file daw_bounded_string.h.

operator!=() [37/51]

template<typename T >

constexpr bool daw::operator!= ( std::nullopt_t  , optional< T > const &  opt  )

constexprnoexcept

Definition at line 334 of file daw_optional.h.

operator!=() [38/51]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator!= ( std::nullptr_t  , copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 174 of file daw_copiable_unique_ptr.h.

operator!=() [39/51]

constexpr bool daw::operator!= ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1305 of file daw_uint_types.h.

operator!=() [40/51]

constexpr bool daw::operator!= ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 994 of file daw_uint_types.h.

operator!=() [41/51]

constexpr bool daw::operator!= ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 412 of file daw_uint_types.h.

operator!=() [42/51]

constexpr bool daw::operator!= ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2858 of file daw_uint_types.h.

operator!=() [43/51]

template<typename CharT >

constexpr bool daw::operator!= ( string_split_iterator< CharT > const &  lhs, string_split_iterator< CharT > const &  rhs  )

constexprnoexcept

Definition at line 109 of file daw_string_split_range.h.

operator!=() [44/51]

template<typename T , typename U >

constexpr bool daw::operator!= ( T const &  value, optional< U > const &  opt  )

constexpr

Definition at line 406 of file daw_optional.h.

operator!=() [45/51]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator!= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1101 of file daw_bounded_string.h.

operator!=() [46/51]

constexpr bool daw::operator!= ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1299 of file daw_uint_types.h.

operator!=() [47/51]

constexpr bool daw::operator!= ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 988 of file daw_uint_types.h.

operator!=() [48/51]

constexpr bool daw::operator!= ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 407 of file daw_uint_types.h.

operator!=() [49/51]

constexpr bool daw::operator!= ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2852 of file daw_uint_types.h.

operator!=() [50/51]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator!= ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 437 of file daw_unique_ptr.h.

operator!=() [51/51]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_inequality< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator!= ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 255 of file daw_value_ptr.h.

operator""_u16()

constexpr UInt16 daw::operator""_u16 ( unsigned long long  value )

constexpr

Definition at line 3326 of file daw_uint_types.h.

operator""_u32()

constexpr UInt32 daw::operator""_u32 ( unsigned long long  value )

constexpr

Definition at line 3320 of file daw_uint_types.h.

operator""_u64()

constexpr UInt64 daw::operator""_u64 ( unsigned long long  value )

constexpr

Definition at line 3316 of file daw_uint_types.h.

operator""_u8()

constexpr UInt8 daw::operator""_u8 ( unsigned long long  value )

constexpr

Definition at line 3332 of file daw_uint_types.h.

operator&() [1/23]

constexpr UInt16 daw::operator& ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1269 of file daw_uint_types.h.

operator&() [2/23]

constexpr UInt32 daw::operator& ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 958 of file daw_uint_types.h.

operator&() [3/23]

constexpr UInt64 daw::operator& ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 352 of file daw_uint_types.h.

operator&() [4/23]

constexpr UInt8 daw::operator& ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2822 of file daw_uint_types.h.

operator&() [5/23]

constexpr UInt16 daw::operator& ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1263 of file daw_uint_types.h.

operator&() [6/23]

constexpr UInt16 daw::operator& ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1369 of file daw_uint_types.h.

operator&() [7/23]

constexpr UInt32 daw::operator& ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1040 of file daw_uint_types.h.

operator&() [8/23]

constexpr UInt64 daw::operator& ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 622 of file daw_uint_types.h.

operator&() [9/23]

constexpr UInt16 daw::operator& ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1374 of file daw_uint_types.h.

operator&() [10/23]

constexpr UInt32 daw::operator& ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 952 of file daw_uint_types.h.

operator&() [11/23]

constexpr UInt32 daw::operator& ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1030 of file daw_uint_types.h.

operator&() [12/23]

constexpr UInt32 daw::operator& ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1025 of file daw_uint_types.h.

operator&() [13/23]

constexpr UInt64 daw::operator& ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 617 of file daw_uint_types.h.

operator&() [14/23]

constexpr UInt32 daw::operator& ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1035 of file daw_uint_types.h.

operator&() [15/23]

constexpr UInt64 daw::operator& ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 347 of file daw_uint_types.h.

operator&() [16/23]

constexpr UInt64 daw::operator& ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 607 of file daw_uint_types.h.

operator&() [17/23]

constexpr UInt64 daw::operator& ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 602 of file daw_uint_types.h.

operator&() [18/23]

constexpr UInt64 daw::operator& ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 597 of file daw_uint_types.h.

operator&() [19/23]

constexpr UInt64 daw::operator& ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 612 of file daw_uint_types.h.

operator&() [20/23]

constexpr UInt8 daw::operator& ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2816 of file daw_uint_types.h.

operator&() [21/23]

constexpr UInt32 daw::operator& ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1045 of file daw_uint_types.h.

operator&() [22/23]

constexpr UInt64 daw::operator& ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 627 of file daw_uint_types.h.

operator&() [23/23]

constexpr UInt8 daw::operator& ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2869 of file daw_uint_types.h.

operator&=() [1/14]

constexpr UInt16 & daw::operator&= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1207 of file daw_uint_types.h.

operator&=() [2/14]

constexpr UInt16 & daw::operator&= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1215 of file daw_uint_types.h.

operator&=() [3/14]

constexpr UInt16 & daw::operator&= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1222 of file daw_uint_types.h.

operator&=() [4/14]

constexpr UInt32 & daw::operator&= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 846 of file daw_uint_types.h.

operator&=() [5/14]

constexpr UInt32 & daw::operator&= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 861 of file daw_uint_types.h.

operator&=() [6/14]

constexpr UInt32 & daw::operator&= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 854 of file daw_uint_types.h.

operator&=() [7/14]

constexpr UInt32 & daw::operator&= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 868 of file daw_uint_types.h.

operator&=() [8/14]

constexpr UInt64 & daw::operator&= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 267 of file daw_uint_types.h.

operator&=() [9/14]

constexpr UInt64 & daw::operator&= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 288 of file daw_uint_types.h.

operator&=() [10/14]

constexpr UInt64 & daw::operator&= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 281 of file daw_uint_types.h.

operator&=() [11/14]

constexpr UInt64 & daw::operator&= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 274 of file daw_uint_types.h.

operator&=() [12/14]

constexpr UInt64 & daw::operator&= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 295 of file daw_uint_types.h.

operator&=() [13/14]

constexpr UInt8 & daw::operator&= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2726 of file daw_uint_types.h.

operator&=() [14/14]

constexpr UInt8 & daw::operator&= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2734 of file daw_uint_types.h.

operator*() [1/27]

constexpr UInt16 daw::operator* ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2338 of file daw_uint_types.h.

operator*() [2/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2038 of file daw_uint_types.h.

operator*() [3/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2033 of file daw_uint_types.h.

operator*() [4/27]

constexpr UInt32 daw::operator* ( std::uint32_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2043 of file daw_uint_types.h.

operator*() [5/27]

constexpr UInt64 daw::operator* ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1617 of file daw_uint_types.h.

operator*() [6/27]

constexpr UInt8 daw::operator* ( std::uint8_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 2564 of file daw_uint_types.h.

operator*() [7/27]

constexpr UInt16 daw::operator* ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2328 of file daw_uint_types.h.

operator*() [8/27]

constexpr UInt16 daw::operator* ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2314 of file daw_uint_types.h.

operator*() [9/27]

constexpr UInt32 daw::operator* ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2019 of file daw_uint_types.h.

operator*() [10/27]

constexpr UInt64 daw::operator* ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1602 of file daw_uint_types.h.

operator*() [11/27]

constexpr UInt16 daw::operator* ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2319 of file daw_uint_types.h.

operator*() [12/27]

constexpr UInt32 daw::operator* ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 2029 of file daw_uint_types.h.

operator*() [13/27]

constexpr UInt32 daw::operator* ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2009 of file daw_uint_types.h.

operator*() [14/27]

constexpr UInt32 daw::operator* ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2004 of file daw_uint_types.h.

operator*() [15/27]

constexpr UInt64 daw::operator* ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1597 of file daw_uint_types.h.

operator*() [16/27]

constexpr UInt32 daw::operator* ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2014 of file daw_uint_types.h.

operator*() [17/27]

constexpr UInt64 daw::operator* ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1612 of file daw_uint_types.h.

operator*() [18/27]

constexpr UInt64 daw::operator* ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1585 of file daw_uint_types.h.

operator*() [19/27]

constexpr UInt64 daw::operator* ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1579 of file daw_uint_types.h.

operator*() [20/27]

constexpr UInt64 daw::operator* ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1573 of file daw_uint_types.h.

operator*() [21/27]

constexpr UInt64 daw::operator* ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1591 of file daw_uint_types.h.

operator*() [22/27]

constexpr UInt16 daw::operator* ( UInt8  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2333 of file daw_uint_types.h.

operator*() [23/27]

constexpr UInt8 daw::operator* ( UInt8  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 2559 of file daw_uint_types.h.

operator*() [24/27]

constexpr UInt16 daw::operator* ( UInt8  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2323 of file daw_uint_types.h.

operator*() [25/27]

constexpr UInt32 daw::operator* ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2024 of file daw_uint_types.h.

operator*() [26/27]

constexpr UInt64 daw::operator* ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1607 of file daw_uint_types.h.

operator*() [27/27]

constexpr UInt8 daw::operator* ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2553 of file daw_uint_types.h.

operator*=() [1/21]

constexpr std::uint16_t & daw::operator*= ( std::uint16_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2300 of file daw_uint_types.h.

operator*=() [2/21]

constexpr std::uint16_t & daw::operator*= ( std::uint16_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2307 of file daw_uint_types.h.

operator*=() [3/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1992 of file daw_uint_types.h.

operator*=() [4/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1986 of file daw_uint_types.h.

operator*=() [5/21]

constexpr std::uint32_t & daw::operator*= ( std::uint32_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1998 of file daw_uint_types.h.

operator*=() [6/21]

constexpr std::uint64_t & daw::operator*= ( std::uint64_t &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1567 of file daw_uint_types.h.

operator*=() [7/21]

constexpr std::uint8_t & daw::operator*= ( std::uint8_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2547 of file daw_uint_types.h.

operator*=() [8/21]

constexpr UInt16 & daw::operator*= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2295 of file daw_uint_types.h.

operator*=() [9/21]

constexpr UInt16 & daw::operator*= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2283 of file daw_uint_types.h.

operator*=() [10/21]

constexpr UInt16 & daw::operator*= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2289 of file daw_uint_types.h.

operator*=() [11/21]

constexpr UInt32 & daw::operator*= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1981 of file daw_uint_types.h.

operator*=() [12/21]

constexpr UInt32 & daw::operator*= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1969 of file daw_uint_types.h.

operator*=() [13/21]

constexpr UInt32 & daw::operator*= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1963 of file daw_uint_types.h.

operator*=() [14/21]

constexpr UInt32 & daw::operator*= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1975 of file daw_uint_types.h.

operator*=() [15/21]

constexpr UInt64 & daw::operator*= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1562 of file daw_uint_types.h.

operator*=() [16/21]

constexpr UInt64 & daw::operator*= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1550 of file daw_uint_types.h.

operator*=() [17/21]

constexpr UInt64 & daw::operator*= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1544 of file daw_uint_types.h.

operator*=() [18/21]

constexpr UInt64 & daw::operator*= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1538 of file daw_uint_types.h.

operator*=() [19/21]

constexpr UInt64 & daw::operator*= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1556 of file daw_uint_types.h.

operator*=() [20/21]

constexpr UInt8 & daw::operator*= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2542 of file daw_uint_types.h.

operator*=() [21/21]

constexpr UInt8 & daw::operator*= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2536 of file daw_uint_types.h.

operator+() [1/44]

template<typename CharT , size_t Capacity>

auto daw::operator+	(	CharT const *	lhs,
		daw::basic_bounded_string< CharT, Capacity > const &	rhs
	)

Definition at line 1256 of file daw_bounded_string.h.

operator+() [2/44]

template<typename CharT , size_t N, size_t Capacity>

auto daw::operator+	(	CharT(&)	lhs[N],
		daw::basic_bounded_string< CharT, Capacity > const &	rhs
	)

Definition at line 1247 of file daw_bounded_string.h.

operator+() [3/44]

template<typename T >

not_null< T > daw::operator+ ( const not_null< T > &  , std::ptrdiff_t    )

delete

operator+() [4/44]

template<typename CharT , size_t Capacity>

auto daw::operator+	(	daw::basic_bounded_string< CharT, Capacity >	lhs,
		CharT const *	rhs
	)

Definition at line 1288 of file daw_bounded_string.h.

operator+() [5/44]

template<typename CharT , size_t Capacity, size_t N>

auto daw::operator+	(	daw::basic_bounded_string< CharT, Capacity >	lhs,
		CharT(&)	rhs[N]
	)

Definition at line 1280 of file daw_bounded_string.h.

operator+() [6/44]

template<typename CharT , size_t Capacity, typename Allocator >

auto daw::operator+	(	daw::basic_bounded_string< CharT, Capacity >	lhs,
		std::basic_string< CharT, Allocator > &&	rhs
	)

Definition at line 1272 of file daw_bounded_string.h.

operator+() [7/44]

template<typename CharT , size_t Capacity, typename Allocator >

auto daw::operator+	(	daw::basic_bounded_string< CharT, Capacity >	lhs,
		std::basic_string< CharT, Allocator > const &	rhs
	)

Definition at line 1265 of file daw_bounded_string.h.

operator+() [8/44]

template<typename CharT , size_t Capacity, typename Allocator >

auto daw::operator+	(	std::basic_string< CharT, Allocator >	lhs,
		daw::basic_bounded_string< CharT, Capacity > const &	rhs
	)

Appending.

Definition at line 1239 of file daw_bounded_string.h.

operator+() [9/44]

template<typename Iterator1 , typename Tag >

constexpr wrap_iter< Iterator1, Tag > daw::operator+ ( std::ptrdiff_t  n, wrap_iter< Iterator1, Tag >  x  )

constexprnoexcept

Definition at line 127 of file wrap_iter.h.

operator+() [10/44]

template<typename T >

not_null< T > daw::operator+ ( std::ptrdiff_t  , const not_null< T > &    )

delete

operator+() [11/44]

constexpr UInt16 daw::operator+ ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2218 of file daw_uint_types.h.

operator+() [12/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1864 of file daw_uint_types.h.

operator+() [13/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1859 of file daw_uint_types.h.

operator+() [14/44]

constexpr UInt32 daw::operator+ ( std::uint32_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1869 of file daw_uint_types.h.

operator+() [15/44]

constexpr UInt64 daw::operator+ ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1458 of file daw_uint_types.h.

operator+() [16/44]

constexpr UInt8 daw::operator+ ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2496 of file daw_uint_types.h.

operator+() [17/44]

template<typename Iterator >

constexpr reverse_iterator< Iterator > daw::operator+ ( typename reverse_iterator< Iterator >::difference_type  n, reverse_iterator< Iterator > const &  it  )

constexpr

Definition at line 121 of file daw_reverse_iterator.h.

operator+() [18/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2209 of file daw_uint_types.h.

operator+() [19/44]

constexpr UInt32 daw::operator+ ( UInt16  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1851 of file daw_uint_types.h.

operator+() [20/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2192 of file daw_uint_types.h.

operator+() [21/44]

constexpr UInt32 daw::operator+ ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1836 of file daw_uint_types.h.

operator+() [22/44]

constexpr UInt64 daw::operator+ ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1444 of file daw_uint_types.h.

operator+() [23/44]

constexpr UInt16 daw::operator+ ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2198 of file daw_uint_types.h.

operator+() [24/44]

constexpr UInt16 daw::operator+ ( UInt16  value )

constexpr

Definition at line 2410 of file daw_uint_types.h.

operator+() [25/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1846 of file daw_uint_types.h.

operator+() [26/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1824 of file daw_uint_types.h.

operator+() [27/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1818 of file daw_uint_types.h.

operator+() [28/44]

constexpr UInt64 daw::operator+ ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1440 of file daw_uint_types.h.

operator+() [29/44]

constexpr UInt32 daw::operator+ ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1830 of file daw_uint_types.h.

operator+() [30/44]

constexpr UInt32 daw::operator+ ( UInt32  value )

constexpr

Definition at line 2126 of file daw_uint_types.h.

operator+() [31/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1453 of file daw_uint_types.h.

operator+() [32/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1432 of file daw_uint_types.h.

operator+() [33/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1428 of file daw_uint_types.h.

operator+() [34/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1424 of file daw_uint_types.h.

operator+() [35/44]

constexpr UInt64 daw::operator+ ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1436 of file daw_uint_types.h.

operator+() [36/44]

constexpr UInt64 daw::operator+ ( UInt64  value )

constexpr

Definition at line 1742 of file daw_uint_types.h.

operator+() [37/44]

constexpr UInt16 daw::operator+ ( UInt8  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2214 of file daw_uint_types.h.

operator+() [38/44]

constexpr UInt32 daw::operator+ ( UInt8  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1855 of file daw_uint_types.h.

operator+() [39/44]

constexpr UInt8 daw::operator+ ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2491 of file daw_uint_types.h.

operator+() [40/44]

constexpr UInt16 daw::operator+ ( UInt8  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2204 of file daw_uint_types.h.

operator+() [41/44]

constexpr UInt32 daw::operator+ ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1841 of file daw_uint_types.h.

operator+() [42/44]

constexpr UInt64 daw::operator+ ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1448 of file daw_uint_types.h.

operator+() [43/44]

constexpr UInt8 daw::operator+ ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2485 of file daw_uint_types.h.

operator+() [44/44]

constexpr UInt8 daw::operator+ ( UInt8  value )

constexpr

Definition at line 2607 of file daw_uint_types.h.

operator++() [1/8]

constexpr UInt16 & daw::operator++ ( UInt16 &  value )

constexpr

Definition at line 2419 of file daw_uint_types.h.

operator++() [2/8]

constexpr UInt16 daw::operator++ ( UInt16 &  value, int    )

constexpr

Definition at line 2424 of file daw_uint_types.h.

operator++() [3/8]

constexpr UInt32 & daw::operator++ ( UInt32 &  value )

constexpr

Definition at line 2135 of file daw_uint_types.h.

operator++() [4/8]

constexpr UInt32 daw::operator++ ( UInt32 &  value, int    )

constexpr

Definition at line 2140 of file daw_uint_types.h.

operator++() [5/8]

constexpr UInt64 & daw::operator++ ( UInt64 &  value )

constexpr

Definition at line 1751 of file daw_uint_types.h.

operator++() [6/8]

constexpr UInt64 daw::operator++ ( UInt64 &  value, int    )

constexpr

Definition at line 1756 of file daw_uint_types.h.

operator++() [7/8]

constexpr UInt8 & daw::operator++ ( UInt8 &  value )

constexpr

Definition at line 2616 of file daw_uint_types.h.

operator++() [8/8]

constexpr UInt8 daw::operator++ ( UInt8 &  value, int    )

constexpr

Definition at line 2621 of file daw_uint_types.h.

operator+=() [1/21]

constexpr std::uint16_t & daw::operator+= ( std::uint16_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2178 of file daw_uint_types.h.

operator+=() [2/21]

constexpr std::uint16_t & daw::operator+= ( std::uint16_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2185 of file daw_uint_types.h.

operator+=() [3/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1806 of file daw_uint_types.h.

operator+=() [4/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1800 of file daw_uint_types.h.

operator+=() [5/21]

constexpr std::uint32_t & daw::operator+= ( std::uint32_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1812 of file daw_uint_types.h.

operator+=() [6/21]

constexpr std::uint64_t & daw::operator+= ( std::uint64_t &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1418 of file daw_uint_types.h.

operator+=() [7/21]

constexpr std::uint8_t & daw::operator+= ( std::uint8_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2479 of file daw_uint_types.h.

operator+=() [8/21]

constexpr UInt16 & daw::operator+= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2173 of file daw_uint_types.h.

operator+=() [9/21]

constexpr UInt16 & daw::operator+= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2161 of file daw_uint_types.h.

operator+=() [10/21]

constexpr UInt16 & daw::operator+= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2167 of file daw_uint_types.h.

operator+=() [11/21]

constexpr UInt32 & daw::operator+= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1795 of file daw_uint_types.h.

operator+=() [12/21]

constexpr UInt32 & daw::operator+= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1783 of file daw_uint_types.h.

operator+=() [13/21]

constexpr UInt32 & daw::operator+= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1777 of file daw_uint_types.h.

operator+=() [14/21]

constexpr UInt32 & daw::operator+= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1789 of file daw_uint_types.h.

operator+=() [15/21]

constexpr UInt64 & daw::operator+= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1413 of file daw_uint_types.h.

operator+=() [16/21]

constexpr UInt64 & daw::operator+= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1401 of file daw_uint_types.h.

operator+=() [17/21]

constexpr UInt64 & daw::operator+= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1395 of file daw_uint_types.h.

operator+=() [18/21]

constexpr UInt64 & daw::operator+= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1389 of file daw_uint_types.h.

operator+=() [19/21]

constexpr UInt64 & daw::operator+= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1407 of file daw_uint_types.h.

operator+=() [20/21]

constexpr UInt8 & daw::operator+= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2474 of file daw_uint_types.h.

operator+=() [21/21]

constexpr UInt8 & daw::operator+= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2468 of file daw_uint_types.h.

operator-() [1/36]

template<typename T , typename U >

std::ptrdiff_t daw::operator- ( const not_null< T > &  , const not_null< U > &    )

delete

operator-() [2/36]

template<typename T >

not_null< T > daw::operator- ( const not_null< T > &  , std::ptrdiff_t    )

delete

operator-() [3/36]

template<class Iterator1 , class Iterator2 >

constexpr auto daw::operator- ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  ) -> decltype( rhs.base( ) - lhs.base( ) )

constexpr

Definition at line 136 of file daw_reverse_iterator.h.

operator-() [4/36]

constexpr UInt16 daw::operator- ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2273 of file daw_uint_types.h.

operator-() [5/36]

constexpr UInt16 daw::operator- ( std::uint16_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2278 of file daw_uint_types.h.

operator-() [6/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1953 of file daw_uint_types.h.

operator-() [7/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1948 of file daw_uint_types.h.

operator-() [8/36]

constexpr UInt32 daw::operator- ( std::uint32_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1958 of file daw_uint_types.h.

operator-() [9/36]

constexpr UInt64 daw::operator- ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1533 of file daw_uint_types.h.

operator-() [10/36]

constexpr UInt8 daw::operator- ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2530 of file daw_uint_types.h.

operator-() [11/36]

template<typename Iterator >

constexpr reverse_iterator< Iterator > daw::operator- ( typename reverse_iterator< Iterator >::difference_type  n, reverse_iterator< Iterator > const &  it  )

constexpr

Definition at line 129 of file daw_reverse_iterator.h.

operator-() [12/36]

constexpr UInt16 daw::operator- ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2269 of file daw_uint_types.h.

operator-() [13/36]

constexpr UInt16 daw::operator- ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2254 of file daw_uint_types.h.

operator-() [14/36]

constexpr UInt32 daw::operator- ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1933 of file daw_uint_types.h.

operator-() [15/36]

constexpr UInt64 daw::operator- ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1519 of file daw_uint_types.h.

operator-() [16/36]

constexpr UInt16 daw::operator- ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2259 of file daw_uint_types.h.

operator-() [17/36]

constexpr UInt16 daw::operator- ( UInt16  value )

constexpr

Definition at line 2414 of file daw_uint_types.h.

operator-() [18/36]

constexpr UInt32 daw::operator- ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1943 of file daw_uint_types.h.

operator-() [19/36]

constexpr UInt32 daw::operator- ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1921 of file daw_uint_types.h.

operator-() [20/36]

constexpr UInt32 daw::operator- ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1915 of file daw_uint_types.h.

operator-() [21/36]

constexpr UInt64 daw::operator- ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1515 of file daw_uint_types.h.

operator-() [22/36]

constexpr UInt32 daw::operator- ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1927 of file daw_uint_types.h.

operator-() [23/36]

constexpr UInt32 daw::operator- ( UInt32  value )

constexpr

Definition at line 2130 of file daw_uint_types.h.

operator-() [24/36]

constexpr UInt64 daw::operator- ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1528 of file daw_uint_types.h.

operator-() [25/36]

constexpr UInt64 daw::operator- ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1505 of file daw_uint_types.h.

operator-() [26/36]

constexpr UInt64 daw::operator- ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1500 of file daw_uint_types.h.

operator-() [27/36]

constexpr UInt64 daw::operator- ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1495 of file daw_uint_types.h.

operator-() [28/36]

constexpr UInt64 daw::operator- ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1510 of file daw_uint_types.h.

operator-() [29/36]

constexpr UInt64 daw::operator- ( UInt64  value )

constexpr

Definition at line 1746 of file daw_uint_types.h.

operator-() [30/36]

constexpr UInt8 daw::operator- ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2525 of file daw_uint_types.h.

operator-() [31/36]

constexpr UInt16 daw::operator- ( UInt8  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2264 of file daw_uint_types.h.

operator-() [32/36]

constexpr UInt32 daw::operator- ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1938 of file daw_uint_types.h.

operator-() [33/36]

constexpr UInt64 daw::operator- ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1523 of file daw_uint_types.h.

operator-() [34/36]

constexpr UInt8 daw::operator- ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2519 of file daw_uint_types.h.

operator-() [35/36]

constexpr UInt8 daw::operator- ( UInt8  value )

constexpr

Definition at line 2611 of file daw_uint_types.h.

operator-() [36/36]

template<typename Iterator1 , class Iterator2 , typename Tag >

constexpr auto daw::operator- ( wrap_iter< Iterator1, Tag > const &  x, wrap_iter< Iterator2, Tag > const &  y  )

constexprnoexcept

Definition at line 120 of file wrap_iter.h.

operator--() [1/8]

constexpr UInt16 & daw::operator-- ( UInt16 &  value )

constexpr

Definition at line 2430 of file daw_uint_types.h.

operator--() [2/8]

constexpr UInt16 daw::operator-- ( UInt16 &  value, int    )

constexpr

Definition at line 2435 of file daw_uint_types.h.

operator--() [3/8]

constexpr UInt32 & daw::operator-- ( UInt32 &  value )

constexpr

Definition at line 2146 of file daw_uint_types.h.

operator--() [4/8]

constexpr UInt32 daw::operator-- ( UInt32 &  value, int    )

constexpr

Definition at line 2151 of file daw_uint_types.h.

operator--() [5/8]

constexpr UInt64 & daw::operator-- ( UInt64 &  value )

constexpr

Definition at line 1762 of file daw_uint_types.h.

operator--() [6/8]

constexpr UInt64 daw::operator-- ( UInt64 &  value, int    )

constexpr

Definition at line 1767 of file daw_uint_types.h.

operator--() [7/8]

constexpr UInt8 & daw::operator-- ( UInt8 &  value )

constexpr

Definition at line 2627 of file daw_uint_types.h.

operator--() [8/8]

constexpr UInt8 daw::operator-- ( UInt8 &  value, int    )

constexpr

Definition at line 2632 of file daw_uint_types.h.

operator-=() [1/21]

constexpr std::uint16_t & daw::operator-= ( std::uint16_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2240 of file daw_uint_types.h.

operator-=() [2/21]

constexpr std::uint16_t & daw::operator-= ( std::uint16_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2247 of file daw_uint_types.h.

operator-=() [3/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1903 of file daw_uint_types.h.

operator-=() [4/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1897 of file daw_uint_types.h.

operator-=() [5/21]

constexpr std::uint32_t & daw::operator-= ( std::uint32_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1909 of file daw_uint_types.h.

operator-=() [6/21]

constexpr std::uint64_t & daw::operator-= ( std::uint64_t &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1489 of file daw_uint_types.h.

operator-=() [7/21]

constexpr std::uint8_t & daw::operator-= ( std::uint8_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2513 of file daw_uint_types.h.

operator-=() [8/21]

constexpr UInt16 & daw::operator-= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2235 of file daw_uint_types.h.

operator-=() [9/21]

constexpr UInt16 & daw::operator-= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2223 of file daw_uint_types.h.

operator-=() [10/21]

constexpr UInt16 & daw::operator-= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2229 of file daw_uint_types.h.

operator-=() [11/21]

constexpr UInt32 & daw::operator-= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 1892 of file daw_uint_types.h.

operator-=() [12/21]

constexpr UInt32 & daw::operator-= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1880 of file daw_uint_types.h.

operator-=() [13/21]

constexpr UInt32 & daw::operator-= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1874 of file daw_uint_types.h.

operator-=() [14/21]

constexpr UInt32 & daw::operator-= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1886 of file daw_uint_types.h.

operator-=() [15/21]

constexpr UInt64 & daw::operator-= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1484 of file daw_uint_types.h.

operator-=() [16/21]

constexpr UInt64 & daw::operator-= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1473 of file daw_uint_types.h.

operator-=() [17/21]

constexpr UInt64 & daw::operator-= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1468 of file daw_uint_types.h.

operator-=() [18/21]

constexpr UInt64 & daw::operator-= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1463 of file daw_uint_types.h.

operator-=() [19/21]

constexpr UInt64 & daw::operator-= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1478 of file daw_uint_types.h.

operator-=() [20/21]

constexpr UInt8 & daw::operator-= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2508 of file daw_uint_types.h.

operator-=() [21/21]

constexpr UInt8 & daw::operator-= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2502 of file daw_uint_types.h.

operator/() [1/30]

constexpr UInt16 daw::operator/ ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2394 of file daw_uint_types.h.

operator/() [2/30]

constexpr UInt16 daw::operator/ ( std::uint16_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2400 of file daw_uint_types.h.

operator/() [3/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2112 of file daw_uint_types.h.

operator/() [4/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2107 of file daw_uint_types.h.

operator/() [5/30]

constexpr UInt32 daw::operator/ ( std::uint32_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2117 of file daw_uint_types.h.

operator/() [6/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1728 of file daw_uint_types.h.

operator/() [7/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1723 of file daw_uint_types.h.

operator/() [8/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1718 of file daw_uint_types.h.

operator/() [9/30]

constexpr UInt64 daw::operator/ ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1733 of file daw_uint_types.h.

operator/() [10/30]

constexpr UInt8 daw::operator/ ( std::uint8_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 2597 of file daw_uint_types.h.

operator/() [11/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2389 of file daw_uint_types.h.

operator/() [12/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2374 of file daw_uint_types.h.

operator/() [13/30]

constexpr UInt32 daw::operator/ ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2092 of file daw_uint_types.h.

operator/() [14/30]

constexpr UInt64 daw::operator/ ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1703 of file daw_uint_types.h.

operator/() [15/30]

constexpr UInt16 daw::operator/ ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2379 of file daw_uint_types.h.

operator/() [16/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 2102 of file daw_uint_types.h.

operator/() [17/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2082 of file daw_uint_types.h.

operator/() [18/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2077 of file daw_uint_types.h.

operator/() [19/30]

constexpr UInt64 daw::operator/ ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1698 of file daw_uint_types.h.

operator/() [20/30]

constexpr UInt32 daw::operator/ ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2087 of file daw_uint_types.h.

operator/() [21/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1713 of file daw_uint_types.h.

operator/() [22/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1686 of file daw_uint_types.h.

operator/() [23/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1680 of file daw_uint_types.h.

operator/() [24/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1675 of file daw_uint_types.h.

operator/() [25/30]

constexpr UInt64 daw::operator/ ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1692 of file daw_uint_types.h.

operator/() [26/30]

constexpr UInt8 daw::operator/ ( UInt8  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 2592 of file daw_uint_types.h.

operator/() [27/30]

constexpr UInt16 daw::operator/ ( UInt8  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2384 of file daw_uint_types.h.

operator/() [28/30]

constexpr UInt32 daw::operator/ ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2097 of file daw_uint_types.h.

operator/() [29/30]

constexpr UInt64 daw::operator/ ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1708 of file daw_uint_types.h.

operator/() [30/30]

constexpr UInt8 daw::operator/ ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2586 of file daw_uint_types.h.

operator/=() [1/22]

constexpr std::uint16_t & daw::operator/= ( std::uint16_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2360 of file daw_uint_types.h.

operator/=() [2/22]

constexpr std::uint16_t & daw::operator/= ( std::uint16_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2367 of file daw_uint_types.h.

operator/=() [3/22]

constexpr std::uint32_t & daw::operator/= ( std::uint32_t &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2071 of file daw_uint_types.h.

operator/=() [4/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1663 of file daw_uint_types.h.

operator/=() [5/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1657 of file daw_uint_types.h.

operator/=() [6/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1651 of file daw_uint_types.h.

operator/=() [7/22]

constexpr std::uint64_t & daw::operator/= ( std::uint64_t &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1669 of file daw_uint_types.h.

operator/=() [8/22]

constexpr std::uint8_t & daw::operator/= ( std::uint8_t &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 2580 of file daw_uint_types.h.

operator/=() [9/22]

constexpr UInt16 & daw::operator/= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 2355 of file daw_uint_types.h.

operator/=() [10/22]

constexpr UInt16 & daw::operator/= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2343 of file daw_uint_types.h.

operator/=() [11/22]

constexpr UInt16 & daw::operator/= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2349 of file daw_uint_types.h.

operator/=() [12/22]

constexpr UInt32 & daw::operator/= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 2066 of file daw_uint_types.h.

operator/=() [13/22]

constexpr UInt32 & daw::operator/= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 2054 of file daw_uint_types.h.

operator/=() [14/22]

constexpr UInt32 & daw::operator/= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 2048 of file daw_uint_types.h.

operator/=() [15/22]

constexpr UInt32 & daw::operator/= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2060 of file daw_uint_types.h.

operator/=() [16/22]

constexpr UInt64 & daw::operator/= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 1646 of file daw_uint_types.h.

operator/=() [17/22]

constexpr UInt64 & daw::operator/= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1634 of file daw_uint_types.h.

operator/=() [18/22]

constexpr UInt64 & daw::operator/= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1628 of file daw_uint_types.h.

operator/=() [19/22]

constexpr UInt64 & daw::operator/= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 1622 of file daw_uint_types.h.

operator/=() [20/22]

constexpr UInt64 & daw::operator/= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1640 of file daw_uint_types.h.

operator/=() [21/22]

constexpr UInt8 & daw::operator/= ( UInt8 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 2575 of file daw_uint_types.h.

operator/=() [22/22]

constexpr UInt8 & daw::operator/= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2569 of file daw_uint_types.h.

operator<() [1/41]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator< ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 808 of file daw_bounded_string.h.

operator<() [2/41]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator< ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1209 of file daw_bounded_string.h.

operator<() [3/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator< ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 181 of file daw_copiable_unique_ptr.h.

operator<() [4/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator< ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 190 of file daw_copiable_unique_ptr.h.

operator<() [5/41]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1159 of file daw_bounded_string.h.

operator<() [6/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 858 of file daw_bounded_string.h.

operator<() [7/41]

template<typename CharT , size_t Capacity>

bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 957 of file daw_bounded_string.h.

operator<() [8/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator< ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1055 of file daw_bounded_string.h.

operator<() [9/41]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator< ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 304 of file daw_not_null.h.

operator<() [10/41]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator< ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 311 of file daw_not_null.h.

operator<() [11/41]

template<typename T >

bool daw::operator<	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 206 of file daw_optional_poly.h.

operator<() [12/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator< ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 908 of file daw_bounded_string.h.

operator<() [13/41]

template<typename T , typename U >

bool daw::operator<	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 280 of file daw_hash_table.h.

operator<() [14/41]

template<typename T , typename U >

bool daw::operator<	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 149 of file deprecated/daw_heap_value.h.

operator<() [15/41]

template<typename T >

constexpr bool daw::operator< ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 316 of file daw_indexed_iterator.h.

operator<() [16/41]

template<typename T , typename U >

constexpr bool daw::operator< ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 193 of file daw_natural.h.

operator<() [17/41]

constexpr bool daw::operator< ( node_id_t const &  lhs, node_id_t const &  rhs  )

constexprnoexcept

Definition at line 82 of file daw_bounded_graph.h.

operator<() [18/41]

template<typename T >

constexpr bool daw::operator< ( optional< T > const &  , std::nullopt_t    )

constexprnoexcept

Definition at line 339 of file daw_optional.h.

operator<() [19/41]

template<typename T , typename U >

constexpr bool daw::operator< ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 275 of file daw_optional.h.

operator<() [20/41]

template<typename T , typename U >

constexpr bool daw::operator< ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 414 of file daw_optional.h.

operator<() [21/41]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator< ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 317 of file daw_not_null.h.

operator<() [22/41]

template<typename T >

bool daw::operator<	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 51 of file daw_reference.h.

operator<() [23/41]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator< ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 156 of file daw_reverse_iterator.h.

operator<() [24/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator< ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1003 of file daw_bounded_string.h.

operator<() [25/41]

template<typename T >

constexpr bool daw::operator< ( std::nullopt_t  , optional< T > const &  opt  )

constexprnoexcept

Definition at line 344 of file daw_optional.h.

operator<() [26/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator< ( std::nullptr_t  , copiable_unique_ptr< T1, D1 > const &  rhs  )

constexprnoexcept

Definition at line 198 of file daw_copiable_unique_ptr.h.

operator<() [27/41]

constexpr bool daw::operator< ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1341 of file daw_uint_types.h.

operator<() [28/41]

constexpr bool daw::operator< ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 922 of file daw_uint_types.h.

operator<() [29/41]

constexpr bool daw::operator< ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 512 of file daw_uint_types.h.

operator<() [30/41]

constexpr bool daw::operator< ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 507 of file daw_uint_types.h.

operator<() [31/41]

constexpr bool daw::operator< ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 502 of file daw_uint_types.h.

operator<() [32/41]

constexpr bool daw::operator< ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 517 of file daw_uint_types.h.

operator<() [33/41]

constexpr bool daw::operator< ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2786 of file daw_uint_types.h.

operator<() [34/41]

template<typename T , typename U >

constexpr bool daw::operator< ( T const &  value, optional< U > const &  opt  )

constexpr

Definition at line 422 of file daw_optional.h.

operator<() [35/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator< ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1109 of file daw_bounded_string.h.

operator<() [36/41]

constexpr bool daw::operator< ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1335 of file daw_uint_types.h.

operator<() [37/41]

constexpr bool daw::operator< ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 916 of file daw_uint_types.h.

operator<() [38/41]

constexpr bool daw::operator< ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 497 of file daw_uint_types.h.

operator<() [39/41]

constexpr bool daw::operator< ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2780 of file daw_uint_types.h.

operator<() [40/41]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator< ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 443 of file daw_unique_ptr.h.

operator<() [41/41]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator< ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 281 of file daw_value_ptr.h.

operator<<() [1/28]

template<typename OStream , typename CharT , size_t Capacity, std::enable_if_t< daw::traits::is_ostream_like_v< OStream, CharT >, std::nullptr_t > = nullptr>

OStream & daw::operator<<	(	OStream &	os,
		daw::basic_bounded_string< CharT, Capacity > const &	str
	)

Definition at line 1355 of file daw_bounded_string.h.

operator<<() [2/28]

template<typename OStream , typename T , std::enable_if_t< daw::traits::is_ostream_like_lite_v< OStream >, std::nullptr_t > = nullptr>

OStream & daw::operator<<	(	OStream &	os,
		Reference< T > const &	ref
	)

Definition at line 95 of file daw_reference.h.

operator<<() [3/28]

template<size_t BitWidth>

std::ostream & daw::operator<< ( std::ostream &  os, static_bitset< BitWidth > const &  bs  )

inline

Definition at line 536 of file daw_static_bitset.h.

operator<<() [4/28]

std::ostream & daw::operator<<	(	std::ostream &	os,
		UInt16	rhs
	)

Definition at line 22 of file daw_uint_buffer_ios.h.

operator<<() [5/28]

std::ostream & daw::operator<<	(	std::ostream &	os,
		UInt32	rhs
	)

Definition at line 27 of file daw_uint_buffer_ios.h.

operator<<() [6/28]

std::ostream & daw::operator<<	(	std::ostream &	os,
		UInt64	rhs
	)

Definition at line 32 of file daw_uint_buffer_ios.h.

operator<<() [7/28]

std::ostream & daw::operator<<	(	std::ostream &	os,
		UInt8	rhs
	)

Definition at line 17 of file daw_uint_buffer_ios.h.

operator<<() [8/28]

constexpr std::uint16_t daw::operator<< ( std::uint16_t  b, UInt16  shift  )

constexprnoexcept

Definition at line 1158 of file daw_uint_types.h.

operator<<() [9/28]

constexpr std::uint32_t daw::operator<< ( std::uint32_t  b, UInt32  shift  )

constexprnoexcept

Definition at line 770 of file daw_uint_types.h.

operator<<() [10/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b, UInt16  shift  )

constexprnoexcept

Definition at line 172 of file daw_uint_types.h.

operator<<() [11/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b, UInt32  shift  )

constexprnoexcept

Definition at line 167 of file daw_uint_types.h.

operator<<() [12/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b, UInt64  shift  )

constexprnoexcept

Definition at line 162 of file daw_uint_types.h.

operator<<() [13/28]

constexpr std::uint64_t daw::operator<< ( std::uint64_t  b, UInt8  shift  )

constexprnoexcept

Definition at line 177 of file daw_uint_types.h.

operator<<() [14/28]

constexpr std::uint8_t daw::operator<< ( std::uint8_t  b, UInt8  shift  )

constexprnoexcept

Definition at line 2684 of file daw_uint_types.h.

operator<<() [15/28]

constexpr UInt16 daw::operator<< ( UInt16  b, std::uint16_t  shift  )

constexprnoexcept

Definition at line 1139 of file daw_uint_types.h.

operator<<() [16/28]

constexpr UInt16 daw::operator<< ( UInt16  b, UInt16  shift  )

constexprnoexcept

Definition at line 1146 of file daw_uint_types.h.

operator<<() [17/28]

constexpr UInt16 daw::operator<< ( UInt16  b, UInt8  shift  )

constexprnoexcept

Definition at line 1152 of file daw_uint_types.h.

operator<<() [18/28]

constexpr UInt32 daw::operator<< ( UInt32  b, std::uint32_t  shift  )

constexprnoexcept

Definition at line 745 of file daw_uint_types.h.

operator<<() [19/28]

constexpr UInt32 daw::operator<< ( UInt32  b, UInt16  shift  )

constexprnoexcept

Definition at line 758 of file daw_uint_types.h.

operator<<() [20/28]

constexpr UInt32 daw::operator<< ( UInt32  b, UInt32  shift  )

constexprnoexcept

Definition at line 752 of file daw_uint_types.h.

operator<<() [21/28]

constexpr UInt32 daw::operator<< ( UInt32  b, UInt8  shift  )

constexprnoexcept

Definition at line 764 of file daw_uint_types.h.

operator<<() [22/28]

constexpr UInt64 daw::operator<< ( UInt64  b, std::uint64_t  shift  )

constexprnoexcept

Definition at line 132 of file daw_uint_types.h.

operator<<() [23/28]

constexpr UInt64 daw::operator<< ( UInt64  b, UInt16  shift  )

constexprnoexcept

Definition at line 150 of file daw_uint_types.h.

operator<<() [24/28]

constexpr UInt64 daw::operator<< ( UInt64  b, UInt32  shift  )

constexprnoexcept

Definition at line 144 of file daw_uint_types.h.

operator<<() [25/28]

constexpr UInt64 daw::operator<< ( UInt64  b, UInt64  shift  )

constexprnoexcept

Definition at line 138 of file daw_uint_types.h.

operator<<() [26/28]

constexpr UInt64 daw::operator<< ( UInt64  b, UInt8  shift  )

constexprnoexcept

Definition at line 156 of file daw_uint_types.h.

operator<<() [27/28]

constexpr UInt8 daw::operator<< ( UInt8  b, std::uint8_t  shift  )

constexprnoexcept

Definition at line 2671 of file daw_uint_types.h.

operator<<() [28/28]

constexpr UInt8 daw::operator<< ( UInt8  b, UInt8  shift  )

constexprnoexcept

Definition at line 2678 of file daw_uint_types.h.

operator<<=() [1/14]

constexpr UInt16 & daw::operator<<= ( UInt16 &  b, std::uint16_t  shift  )

constexprnoexcept

Definition at line 1095 of file daw_uint_types.h.

operator<<=() [2/14]

constexpr UInt16 & daw::operator<<= ( UInt16 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 1103 of file daw_uint_types.h.

operator<<=() [3/14]

constexpr UInt16 & daw::operator<<= ( UInt16 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 1110 of file daw_uint_types.h.

operator<<=() [4/14]

constexpr UInt32 & daw::operator<<= ( UInt32 &  b, std::uint32_t  shift  )

constexprnoexcept

Definition at line 687 of file daw_uint_types.h.

operator<<=() [5/14]

constexpr UInt32 & daw::operator<<= ( UInt32 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 702 of file daw_uint_types.h.

operator<<=() [6/14]

constexpr UInt32 & daw::operator<<= ( UInt32 &  b, UInt32  shift  )

constexprnoexcept

Definition at line 695 of file daw_uint_types.h.

operator<<=() [7/14]

constexpr UInt32 & daw::operator<<= ( UInt32 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 709 of file daw_uint_types.h.

operator<<=() [8/14]

constexpr UInt64 & daw::operator<<= ( UInt64 &  b, std::uint64_t  shift  )

constexprnoexcept

Definition at line 62 of file daw_uint_types.h.

operator<<=() [9/14]

constexpr UInt64 & daw::operator<<= ( UInt64 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 83 of file daw_uint_types.h.

operator<<=() [10/14]

constexpr UInt64 & daw::operator<<= ( UInt64 &  b, UInt32  shift  )

constexprnoexcept

Definition at line 76 of file daw_uint_types.h.

operator<<=() [11/14]

constexpr UInt64 & daw::operator<<= ( UInt64 &  b, UInt64  shift  )

constexprnoexcept

Definition at line 69 of file daw_uint_types.h.

operator<<=() [12/14]

constexpr UInt64 & daw::operator<<= ( UInt64 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 90 of file daw_uint_types.h.

operator<<=() [13/14]

constexpr UInt8 & daw::operator<<= ( UInt8 &  b, std::uint8_t  shift  )

constexprnoexcept

Definition at line 2641 of file daw_uint_types.h.

operator<<=() [14/14]

constexpr UInt8 & daw::operator<<= ( UInt8 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 2649 of file daw_uint_types.h.

operator<=() [1/43]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator<= ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 816 of file daw_bounded_string.h.

operator<=() [2/43]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator<= ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1216 of file daw_bounded_string.h.

operator<=() [3/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator<= ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 206 of file daw_copiable_unique_ptr.h.

operator<=() [4/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator<= ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 212 of file daw_copiable_unique_ptr.h.

operator<=() [5/43]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1167 of file daw_bounded_string.h.

operator<=() [6/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 866 of file daw_bounded_string.h.

operator<=() [7/43]

template<typename CharT , size_t Capacity>

bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 964 of file daw_bounded_string.h.

operator<=() [8/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator<= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1064 of file daw_bounded_string.h.

operator<=() [9/43]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 323 of file daw_not_null.h.

operator<=() [10/43]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 330 of file daw_not_null.h.

operator<=() [11/43]

template<typename T >

bool daw::operator<=	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 218 of file daw_optional_poly.h.

operator<=() [12/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator<= ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 916 of file daw_bounded_string.h.

operator<=() [13/43]

template<typename T , typename U >

bool daw::operator<=	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 286 of file daw_hash_table.h.

operator<=() [14/43]

template<typename T , typename U >

bool daw::operator<=	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 139 of file deprecated/daw_heap_value.h.

operator<=() [15/43]

template<typename T >

constexpr bool daw::operator<= ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 328 of file daw_indexed_iterator.h.

operator<=() [16/43]

template<typename T , typename U >

constexpr bool daw::operator<= ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 199 of file daw_natural.h.

operator<=() [17/43]

template<typename T , typename U >

constexpr bool daw::operator<= ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 286 of file daw_optional.h.

operator<=() [18/43]

template<typename T >

constexpr bool daw::operator<= ( optional< T > const &  opt, std::nullopt_t    )

constexprnoexcept

Definition at line 349 of file daw_optional.h.

operator<=() [19/43]

template<typename T , typename U >

constexpr bool daw::operator<= ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 430 of file daw_optional.h.

operator<=() [20/43]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator<= ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 336 of file daw_not_null.h.

operator<=() [21/43]

template<typename T >

bool daw::operator<=	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 56 of file daw_reference.h.

operator<=() [22/43]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator<= ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 162 of file daw_reverse_iterator.h.

operator<=() [23/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator<= ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1011 of file daw_bounded_string.h.

operator<=() [24/43]

template<typename T >

constexpr bool daw::operator<= ( std::nullopt_t  , optional< T > const &    )

constexprnoexcept

Definition at line 354 of file daw_optional.h.

operator<=() [25/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator<= ( std::nullptr_t  , copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 219 of file daw_copiable_unique_ptr.h.

operator<=() [26/43]

constexpr bool daw::operator<= ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1353 of file daw_uint_types.h.

operator<=() [27/43]

constexpr bool daw::operator<= ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 934 of file daw_uint_types.h.

operator<=() [28/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 552 of file daw_uint_types.h.

operator<=() [29/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 547 of file daw_uint_types.h.

operator<=() [30/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 542 of file daw_uint_types.h.

operator<=() [31/43]

constexpr bool daw::operator<= ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 557 of file daw_uint_types.h.

operator<=() [32/43]

constexpr bool daw::operator<= ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2798 of file daw_uint_types.h.

operator<=() [33/43]

template<typename T , typename U >

constexpr bool daw::operator<= ( T const &  value, optional< U > const &  opt  )

constexpr

Definition at line 438 of file daw_optional.h.

operator<=() [34/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator<= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1117 of file daw_bounded_string.h.

operator<=() [35/43]

constexpr bool daw::operator<= ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1347 of file daw_uint_types.h.

operator<=() [36/43]

constexpr bool daw::operator<= ( UInt16  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 532 of file daw_uint_types.h.

operator<=() [37/43]

constexpr bool daw::operator<= ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 928 of file daw_uint_types.h.

operator<=() [38/43]

constexpr bool daw::operator<= ( UInt32  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 527 of file daw_uint_types.h.

operator<=() [39/43]

constexpr bool daw::operator<= ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 522 of file daw_uint_types.h.

operator<=() [40/43]

constexpr bool daw::operator<= ( UInt8  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 537 of file daw_uint_types.h.

operator<=() [41/43]

constexpr bool daw::operator<= ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2792 of file daw_uint_types.h.

operator<=() [42/43]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator<= ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 449 of file daw_unique_ptr.h.

operator<=() [43/43]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_less_equal< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator<= ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 290 of file daw_value_ptr.h.

operator==() [1/57]

template<typename T , typename U , size_t N>

constexpr bool daw::operator== ( array< T, N > const &  lhs, array< U, N > const &  rhs  )

constexpr

Definition at line 102 of file daw_bounded_array.h.

operator==() [2/57]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator== ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 793 of file daw_bounded_string.h.

operator==() [3/57]

template<typename Key , typename Value >

constexpr bool daw::operator== ( bounded_hash_map_iterator< Key, Value > const &  lhs, bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 248 of file daw_bounded_hash_map.h.

operator==() [4/57]

template<typename Key , typename Value >

constexpr bool daw::operator== ( bounded_hash_map_iterator< Key, Value > const &  lhs, const_bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 262 of file daw_bounded_hash_map.h.

operator==() [5/57]

template<typename Key >

constexpr bool daw::operator== ( bounded_hash_set_iterator< Key > const &  lhs, bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 226 of file daw_bounded_hash_set.h.

operator==() [6/57]

template<typename Key >

constexpr bool daw::operator== ( bounded_hash_set_iterator< Key > const &  lhs, const_bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 240 of file daw_bounded_hash_set.h.

operator==() [7/57]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator== ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1194 of file daw_bounded_string.h.

operator==() [8/57]

template<typename Key , typename Value >

constexpr bool daw::operator== ( const_bounded_hash_map_iterator< Key, Value > const &  lhs, bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 269 of file daw_bounded_hash_map.h.

operator==() [9/57]

template<typename Key , typename Value >

constexpr bool daw::operator== ( const_bounded_hash_map_iterator< Key, Value > const &  lhs, const_bounded_hash_map_iterator< Key, Value > const &  rhs  )

constexpr

Definition at line 255 of file daw_bounded_hash_map.h.

operator==() [10/57]

template<typename Key >

constexpr bool daw::operator== ( const_bounded_hash_set_iterator< Key > const &  lhs, bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 247 of file daw_bounded_hash_set.h.

operator==() [11/57]

template<typename Key >

constexpr bool daw::operator== ( const_bounded_hash_set_iterator< Key > const &  lhs, const_bounded_hash_set_iterator< Key > const &  rhs  )

constexprnoexcept

Definition at line 233 of file daw_bounded_hash_set.h.

operator==() [12/57]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator== ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 142 of file daw_copiable_unique_ptr.h.

operator==() [13/57]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator== ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 148 of file daw_copiable_unique_ptr.h.

operator==() [14/57]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1144 of file daw_bounded_string.h.

operator==() [15/57]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 843 of file daw_bounded_string.h.

operator==() [16/57]

template<typename CharT , size_t Capacity>

bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 943 of file daw_bounded_string.h.

operator==() [17/57]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator== ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1038 of file daw_bounded_string.h.

operator==() [18/57]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator== ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 267 of file daw_not_null.h.

operator==() [19/57]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator== ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 274 of file daw_not_null.h.

operator==() [20/57]

template<typename T >

bool daw::operator==	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 182 of file daw_optional_poly.h.

operator==() [21/57]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator== ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 893 of file daw_bounded_string.h.

operator==() [22/57]

template<typename T , typename U >

bool daw::operator==	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 256 of file daw_hash_table.h.

operator==() [23/57]

template<typename T , typename U >

bool daw::operator==	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 124 of file deprecated/daw_heap_value.h.

operator==() [24/57]

template<typename T , typename U , std::enable_if_t< not std::is_convertible_v< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator== ( indexed_iterator< T > const &  , indexed_iterator< U > const &    )

constexprnoexcept

Definition at line 295 of file daw_indexed_iterator.h.

operator==() [25/57]

template<typename T >

constexpr bool daw::operator== ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 286 of file daw_indexed_iterator.h.

operator==() [26/57]

template<typename T , typename U >

constexpr bool daw::operator== ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 181 of file daw_natural.h.

operator==() [27/57]

constexpr bool daw::operator== ( node_id_t const &  lhs, node_id_t const &  rhs  )

constexprnoexcept

Definition at line 72 of file daw_bounded_graph.h.

operator==() [28/57]

template<typename T , typename U >

constexpr bool daw::operator== ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 253 of file daw_optional.h.

operator==() [29/57]

template<typename T >

constexpr bool daw::operator== ( optional< T > const &  opt, std::nullopt_t    )

constexprnoexcept

Definition at line 319 of file daw_optional.h.

operator==() [30/57]

template<typename T , typename U >

constexpr bool daw::operator== ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 382 of file daw_optional.h.

operator==() [31/57]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator== ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 280 of file daw_not_null.h.

operator==() [32/57]

template<typename T >

bool daw::operator==	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 41 of file daw_reference.h.

operator==() [33/57]

template<typename CharT >

constexpr bool daw::operator== ( repeat_n_char_iterator< CharT > const &  lhs, repeat_n_char_iterator< CharT > const &  rhs  )

constexprnoexcept

Definition at line 111 of file daw_repeat_n_char_iterator.h.

operator==() [34/57]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator== ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 144 of file daw_reverse_iterator.h.

operator==() [35/57]

template<typename Iterator >

constexpr bool daw::operator== ( splitter_range_t< Iterator > const &  lhs, splitter_range_t< Iterator > const &  rhs  )

constexprnoexcept

Definition at line 81 of file daw_split_iterator.h.

operator==() [36/57]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator== ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 988 of file daw_bounded_string.h.

operator==() [37/57]

template<typename T >

constexpr bool daw::operator== ( std::nullopt_t  , optional< T > const &  opt  )

constexprnoexcept

Definition at line 324 of file daw_optional.h.

operator==() [38/57]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator== ( std::nullptr_t  , copiable_unique_ptr< T1, D1 > const &  rhs  )

constexprnoexcept

Definition at line 154 of file daw_copiable_unique_ptr.h.

operator==() [39/57]

constexpr bool daw::operator== ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1293 of file daw_uint_types.h.

operator==() [40/57]

constexpr bool daw::operator== ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 982 of file daw_uint_types.h.

operator==() [41/57]

constexpr bool daw::operator== ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 397 of file daw_uint_types.h.

operator==() [42/57]

constexpr bool daw::operator== ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 392 of file daw_uint_types.h.

operator==() [43/57]

constexpr bool daw::operator== ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 387 of file daw_uint_types.h.

operator==() [44/57]

constexpr bool daw::operator== ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 402 of file daw_uint_types.h.

operator==() [45/57]

constexpr bool daw::operator== ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2846 of file daw_uint_types.h.

operator==() [46/57]

template<typename CharT >

constexpr bool daw::operator== ( string_split_iterator< CharT > const &  lhs, string_split_iterator< CharT > const &  rhs  )

constexprnoexcept

Definition at line 102 of file daw_string_split_range.h.

operator==() [47/57]

template<typename T , typename U >

constexpr bool daw::operator== ( T const &  value, optional< U > const &  opt  )

constexpr

Definition at line 390 of file daw_optional.h.

operator==() [48/57]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator== ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1093 of file daw_bounded_string.h.

operator==() [49/57]

constexpr bool daw::operator== ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1287 of file daw_uint_types.h.

operator==() [50/57]

constexpr bool daw::operator== ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 976 of file daw_uint_types.h.

operator==() [51/57]

constexpr bool daw::operator== ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 367 of file daw_uint_types.h.

operator==() [52/57]

constexpr bool daw::operator== ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 377 of file daw_uint_types.h.

operator==() [53/57]

constexpr bool daw::operator== ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 372 of file daw_uint_types.h.

operator==() [54/57]

constexpr bool daw::operator== ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 382 of file daw_uint_types.h.

operator==() [55/57]

constexpr bool daw::operator== ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2840 of file daw_uint_types.h.

operator==() [56/57]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator== ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 431 of file daw_unique_ptr.h.

operator==() [57/57]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_equality< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator== ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 245 of file daw_value_ptr.h.

operator>() [1/41]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator> ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 825 of file daw_bounded_string.h.

operator>() [2/41]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator> ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1224 of file daw_bounded_string.h.

operator>() [3/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator> ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 226 of file daw_copiable_unique_ptr.h.

operator>() [4/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator> ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 232 of file daw_copiable_unique_ptr.h.

operator>() [5/41]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1176 of file daw_bounded_string.h.

operator>() [6/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 875 of file daw_bounded_string.h.

operator>() [7/41]

template<typename CharT , size_t Capacity>

bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 971 of file daw_bounded_string.h.

operator>() [8/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator> ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1074 of file daw_bounded_string.h.

operator>() [9/41]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator> ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 343 of file daw_not_null.h.

operator>() [10/41]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator> ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 350 of file daw_not_null.h.

operator>() [11/41]

template<typename T >

bool daw::operator>	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 230 of file daw_optional_poly.h.

operator>() [12/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator> ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 925 of file daw_bounded_string.h.

operator>() [13/41]

template<typename T , typename U >

bool daw::operator>	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 268 of file daw_hash_table.h.

operator>() [14/41]

template<typename T , typename U >

bool daw::operator>	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 144 of file deprecated/daw_heap_value.h.

operator>() [15/41]

template<typename T >

constexpr bool daw::operator> ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 322 of file daw_indexed_iterator.h.

operator>() [16/41]

template<typename T , typename U >

constexpr bool daw::operator> ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 205 of file daw_natural.h.

operator>() [17/41]

template<typename T , typename U >

constexpr bool daw::operator> ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 297 of file daw_optional.h.

operator>() [18/41]

template<typename T >

constexpr bool daw::operator> ( optional< T > const &  opt, std::nullopt_t    )

constexprnoexcept

Definition at line 360 of file daw_optional.h.

operator>() [19/41]

template<typename T , typename U >

constexpr bool daw::operator> ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 446 of file daw_optional.h.

operator>() [20/41]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator> ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 356 of file daw_not_null.h.

operator>() [21/41]

template<typename T >

bool daw::operator>	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 61 of file daw_reference.h.

operator>() [22/41]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator> ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 168 of file daw_reverse_iterator.h.

operator>() [23/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator> ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1020 of file daw_bounded_string.h.

operator>() [24/41]

template<typename T >

constexpr bool daw::operator> ( std::nullopt_t  , optional< T > const &    )

constexprnoexcept

Definition at line 365 of file daw_optional.h.

operator>() [25/41]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator> ( std::nullptr_t  , copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 239 of file daw_copiable_unique_ptr.h.

operator>() [26/41]

constexpr bool daw::operator> ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1317 of file daw_uint_types.h.

operator>() [27/41]

constexpr bool daw::operator> ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 447 of file daw_uint_types.h.

operator>() [28/41]

constexpr bool daw::operator> ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 442 of file daw_uint_types.h.

operator>() [29/41]

constexpr bool daw::operator> ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 437 of file daw_uint_types.h.

operator>() [30/41]

constexpr bool daw::operator> ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 452 of file daw_uint_types.h.

operator>() [31/41]

constexpr bool daw::operator> ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2762 of file daw_uint_types.h.

operator>() [32/41]

template<typename T , typename U >

constexpr bool daw::operator> ( T const &  value, optional< U > const &  opt  )

constexpr

Definition at line 454 of file daw_optional.h.

operator>() [33/41]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator> ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1125 of file daw_bounded_string.h.

operator>() [34/41]

constexpr bool daw::operator> ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1311 of file daw_uint_types.h.

operator>() [35/41]

constexpr bool daw::operator> ( UInt16  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 427 of file daw_uint_types.h.

operator>() [36/41]

constexpr bool daw::operator> ( UInt32  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 422 of file daw_uint_types.h.

operator>() [37/41]

constexpr bool daw::operator> ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 417 of file daw_uint_types.h.

operator>() [38/41]

constexpr bool daw::operator> ( UInt8  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 432 of file daw_uint_types.h.

operator>() [39/41]

constexpr bool daw::operator> ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2756 of file daw_uint_types.h.

operator>() [40/41]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator> ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 455 of file daw_unique_ptr.h.

operator>() [41/41]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator> ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 264 of file daw_value_ptr.h.

operator>=() [1/43]

template<typename CharT , size_t CapacityL, size_t CapacityR>

constexpr bool daw::operator>= ( basic_bounded_string< CharT, CapacityL > const &  lhs, basic_bounded_string< CharT, CapacityR > const &  rhs  )

constexprnoexcept

Definition at line 833 of file daw_bounded_string.h.

operator>=() [2/43]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator>= ( CharT const (&)  lhs[N], daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1231 of file daw_bounded_string.h.

operator>=() [3/43]

template<typename T , typename U >

constexpr bool daw::operator>= ( const T &  value, const optional< U > &  opt  )

constexpr

Definition at line 470 of file daw_optional.h.

operator>=() [4/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator>= ( copiable_unique_ptr< T1, D1 > const &  lhs, copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 246 of file daw_copiable_unique_ptr.h.

operator>=() [5/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator>= ( copiable_unique_ptr< T1, D1 > const &  lhs, std::nullptr_t    )

constexprnoexcept

Definition at line 252 of file daw_copiable_unique_ptr.h.

operator>=() [6/43]

template<typename CharT , size_t Capacity, size_t N>

constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, CharT const (&)  rhs[N]  )

constexprnoexcept

Definition at line 1184 of file daw_bounded_string.h.

operator>=() [7/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, daw::sv1::basic_string_view< CharT >  rhs  )

constexprnoexcept

Definition at line 883 of file daw_bounded_string.h.

operator>=() [8/43]

template<typename CharT , size_t Capacity>

bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity > const &  lhs, std::basic_string< CharT > const &  rhs  )

noexcept

Definition at line 978 of file daw_bounded_string.h.

operator>=() [9/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator>= ( daw::basic_bounded_string< CharT, Capacity >  lhs, typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  rhs  )

constexprnoexcept

Definition at line 1083 of file daw_bounded_string.h.

operator>=() [10/43]

template<typename Lhs , typename Rhs >

DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( daw::not_null< Lhs > const &  lhs, daw::not_null< Rhs > const &  rhs  )

constexprnoexcept

Definition at line 362 of file daw_not_null.h.

operator>=() [11/43]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( daw::not_null< Pointer > const &  lhs, Pointer const &  rhs  )

constexprnoexcept

Definition at line 369 of file daw_not_null.h.

operator>=() [12/43]

template<typename T >

bool daw::operator>=	(	daw::optional_poly< T > const &	lhs,
		daw::optional_poly< T > const &	rhs
	)

Definition at line 242 of file daw_optional_poly.h.

operator>=() [13/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator>= ( daw::sv1::basic_string_view< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 933 of file daw_bounded_string.h.

operator>=() [14/43]

template<typename T , typename U >

bool daw::operator>=	(	hash_table_item_iterator< T > const &	lhs,
		hash_table_item_iterator< U > const &	rhs
	)

Definition at line 274 of file daw_hash_table.h.

operator>=() [15/43]

template<typename T , typename U >

bool daw::operator>=	(	heap_value< T > const &	lhs,
		heap_value< U > const &	rhs
	)

Definition at line 134 of file deprecated/daw_heap_value.h.

operator>=() [16/43]

template<typename T >

constexpr bool daw::operator>= ( indexed_iterator< T > const &  lhs, indexed_iterator< T > const &  rhs  )

constexprnoexcept

Definition at line 334 of file daw_indexed_iterator.h.

operator>=() [17/43]

template<typename T , typename U >

constexpr bool daw::operator>= ( natural_t< T > const &  lhs, natural_t< U > const &  rhs  )

constexprnoexcept

Definition at line 211 of file daw_natural.h.

operator>=() [18/43]

template<typename T >

constexpr bool daw::operator>= ( optional< T > const &  , std::nullopt_t    )

constexprnoexcept

Definition at line 371 of file daw_optional.h.

operator>=() [19/43]

template<typename T , typename U >

constexpr bool daw::operator>= ( optional< T > const &  lhs, optional< U > const &  rhs  )

constexpr

Definition at line 308 of file daw_optional.h.

operator>=() [20/43]

template<typename T , typename U >

constexpr bool daw::operator>= ( optional< T > const &  opt, U const &  value  )

constexpr

Definition at line 462 of file daw_optional.h.

operator>=() [21/43]

template<typename Pointer >

DAW_ATTRIB_INLINE constexpr bool daw::operator>= ( Pointer const &  lhs, daw::not_null< Pointer > const &  rhs  )

constexprnoexcept

Definition at line 375 of file daw_not_null.h.

operator>=() [22/43]

template<typename T >

bool daw::operator>=	(	Reference< T > const &	lhs,
		Reference< T > const &	rhs
	)

Definition at line 66 of file daw_reference.h.

operator>=() [23/43]

template<typename Iterator1 , typename Iterator2 >

constexpr bool daw::operator>= ( reverse_iterator< Iterator1 > const &  lhs, reverse_iterator< Iterator2 > const &  rhs  )

constexpr

Definition at line 174 of file daw_reverse_iterator.h.

operator>=() [24/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator>= ( std::basic_string< CharT > const &  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1028 of file daw_bounded_string.h.

operator>=() [25/43]

template<typename T >

constexpr bool daw::operator>= ( std::nullopt_t  , optional< T > const &  opt  )

constexprnoexcept

Definition at line 377 of file daw_optional.h.

operator>=() [26/43]

template<typename T1 , typename D1 , typename T2 , typename D2 >

constexpr bool daw::operator>= ( std::nullptr_t  , copiable_unique_ptr< T2, D2 > const &  rhs  )

constexprnoexcept

Definition at line 259 of file daw_copiable_unique_ptr.h.

operator>=() [27/43]

constexpr bool daw::operator>= ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1329 of file daw_uint_types.h.

operator>=() [28/43]

constexpr bool daw::operator>= ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 910 of file daw_uint_types.h.

operator>=() [29/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 487 of file daw_uint_types.h.

operator>=() [30/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 482 of file daw_uint_types.h.

operator>=() [31/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 477 of file daw_uint_types.h.

operator>=() [32/43]

constexpr bool daw::operator>= ( std::uint64_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 492 of file daw_uint_types.h.

operator>=() [33/43]

constexpr bool daw::operator>= ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2774 of file daw_uint_types.h.

operator>=() [34/43]

template<typename CharT , size_t Capacity>

constexpr bool daw::operator>= ( typename daw::basic_bounded_string< CharT, Capacity >::const_pointer  lhs, daw::basic_bounded_string< CharT, Capacity > const &  rhs  )

constexprnoexcept

Definition at line 1133 of file daw_bounded_string.h.

operator>=() [35/43]

constexpr bool daw::operator>= ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1323 of file daw_uint_types.h.

operator>=() [36/43]

constexpr bool daw::operator>= ( UInt16  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 467 of file daw_uint_types.h.

operator>=() [37/43]

constexpr bool daw::operator>= ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 904 of file daw_uint_types.h.

operator>=() [38/43]

constexpr bool daw::operator>= ( UInt32  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 462 of file daw_uint_types.h.

operator>=() [39/43]

constexpr bool daw::operator>= ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 457 of file daw_uint_types.h.

operator>=() [40/43]

constexpr bool daw::operator>= ( UInt8  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 472 of file daw_uint_types.h.

operator>=() [41/43]

constexpr bool daw::operator>= ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2768 of file daw_uint_types.h.

operator>=() [42/43]

template<typename T , typename D0 , typename D1 = D0>

constexpr bool daw::operator>= ( unique_ptr< T, D0 > const &  lhs, unique_ptr< T, D1 > const &  rhs  )

constexprnoexcept

Definition at line 461 of file daw_unique_ptr.h.

operator>=() [43/43]

template<typename T , typename U , std::enable_if_t< value_ptr_details::has_compare_greater_equal< T, U >, std::nullptr_t > = nullptr>

constexpr bool daw::operator>= ( value_ptr< T > const &  lhs, value_ptr< U > const &  rhs  )

constexprnoexcept

Definition at line 273 of file daw_value_ptr.h.

operator>>() [1/22]

constexpr std::uint16_t daw::operator>> ( std::uint16_t  b, UInt16  shift  )

constexprnoexcept

Definition at line 1178 of file daw_uint_types.h.

operator>>() [2/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b, UInt16  shift  )

constexprnoexcept

Definition at line 805 of file daw_uint_types.h.

operator>>() [3/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b, UInt32  shift  )

constexprnoexcept

Definition at line 799 of file daw_uint_types.h.

operator>>() [4/22]

constexpr std::uint32_t daw::operator>> ( std::uint32_t  b, UInt8  shift  )

constexprnoexcept

Definition at line 811 of file daw_uint_types.h.

operator>>() [5/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b, UInt16  shift  )

constexprnoexcept

Definition at line 222 of file daw_uint_types.h.

operator>>() [6/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b, UInt32  shift  )

constexprnoexcept

Definition at line 217 of file daw_uint_types.h.

operator>>() [7/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b, UInt64  shift  )

constexprnoexcept

Definition at line 212 of file daw_uint_types.h.

operator>>() [8/22]

constexpr std::uint64_t daw::operator>> ( std::uint64_t  b, UInt8  shift  )

constexprnoexcept

Definition at line 227 of file daw_uint_types.h.

operator>>() [9/22]

constexpr std::uint8_t daw::operator>> ( std::uint8_t  b, UInt8  shift  )

constexprnoexcept

Definition at line 2704 of file daw_uint_types.h.

operator>>() [10/22]

constexpr UInt16 daw::operator>> ( UInt16  b, std::uint16_t  shift  )

constexprnoexcept

Definition at line 1165 of file daw_uint_types.h.

operator>>() [11/22]

constexpr UInt16 daw::operator>> ( UInt16  b, UInt16  shift  )

constexprnoexcept

Definition at line 1172 of file daw_uint_types.h.

operator>>() [12/22]

constexpr UInt32 daw::operator>> ( UInt32  b, std::uint32_t  shift  )

constexprnoexcept

Definition at line 776 of file daw_uint_types.h.

operator>>() [13/22]

constexpr UInt32 daw::operator>> ( UInt32  b, UInt16  shift  )

constexprnoexcept

Definition at line 788 of file daw_uint_types.h.

operator>>() [14/22]

constexpr UInt32 daw::operator>> ( UInt32  b, UInt32  shift  )

constexprnoexcept

Definition at line 783 of file daw_uint_types.h.

operator>>() [15/22]

constexpr UInt32 daw::operator>> ( UInt32  b, UInt8  shift  )

constexprnoexcept

Definition at line 793 of file daw_uint_types.h.

operator>>() [16/22]

constexpr UInt64 daw::operator>> ( UInt64  b, std::uint64_t  shift  )

constexprnoexcept

Definition at line 182 of file daw_uint_types.h.

operator>>() [17/22]

constexpr UInt64 daw::operator>> ( UInt64  b, UInt16  shift  )

constexprnoexcept

Definition at line 200 of file daw_uint_types.h.

operator>>() [18/22]

constexpr UInt64 daw::operator>> ( UInt64  b, UInt32  shift  )

constexprnoexcept

Definition at line 194 of file daw_uint_types.h.

operator>>() [19/22]

constexpr UInt64 daw::operator>> ( UInt64  b, UInt64  shift  )

constexprnoexcept

Definition at line 188 of file daw_uint_types.h.

operator>>() [20/22]

constexpr UInt64 daw::operator>> ( UInt64  b, UInt8  shift  )

constexprnoexcept

Definition at line 206 of file daw_uint_types.h.

operator>>() [21/22]

constexpr UInt8 daw::operator>> ( UInt8  b, std::uint8_t  shift  )

constexprnoexcept

Definition at line 2691 of file daw_uint_types.h.

operator>>() [22/22]

constexpr UInt8 daw::operator>> ( UInt8  b, UInt8  shift  )

constexprnoexcept

Definition at line 2698 of file daw_uint_types.h.

operator>>=() [1/14]

constexpr UInt16 & daw::operator>>= ( UInt16 &  b, std::uint16_t  shift  )

constexprnoexcept

Definition at line 1117 of file daw_uint_types.h.

operator>>=() [2/14]

constexpr UInt16 & daw::operator>>= ( UInt16 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 1125 of file daw_uint_types.h.

operator>>=() [3/14]

constexpr UInt16 & daw::operator>>= ( UInt16 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 1132 of file daw_uint_types.h.

operator>>=() [4/14]

constexpr UInt32 & daw::operator>>= ( UInt32 &  b, std::uint32_t  shift  )

constexprnoexcept

Definition at line 716 of file daw_uint_types.h.

operator>>=() [5/14]

constexpr UInt32 & daw::operator>>= ( UInt32 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 731 of file daw_uint_types.h.

operator>>=() [6/14]

constexpr UInt32 & daw::operator>>= ( UInt32 &  b, UInt32  shift  )

constexprnoexcept

Definition at line 724 of file daw_uint_types.h.

operator>>=() [7/14]

constexpr UInt32 & daw::operator>>= ( UInt32 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 738 of file daw_uint_types.h.

operator>>=() [8/14]

constexpr UInt64 & daw::operator>>= ( UInt64 &  b, std::uint64_t  shift  )

constexprnoexcept

Definition at line 97 of file daw_uint_types.h.

operator>>=() [9/14]

constexpr UInt64 & daw::operator>>= ( UInt64 &  b, UInt16  shift  )

constexprnoexcept

Definition at line 118 of file daw_uint_types.h.

operator>>=() [10/14]

constexpr UInt64 & daw::operator>>= ( UInt64 &  b, UInt32  shift  )

constexprnoexcept

Definition at line 111 of file daw_uint_types.h.

operator>>=() [11/14]

constexpr UInt64 & daw::operator>>= ( UInt64 &  b, UInt64  shift  )

constexprnoexcept

Definition at line 104 of file daw_uint_types.h.

operator>>=() [12/14]

constexpr UInt64 & daw::operator>>= ( UInt64 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 125 of file daw_uint_types.h.

operator>>=() [13/14]

constexpr UInt8 & daw::operator>>= ( UInt8 &  b, std::uint8_t  shift  )

constexprnoexcept

Definition at line 2656 of file daw_uint_types.h.

operator>>=() [14/14]

constexpr UInt8 & daw::operator>>= ( UInt8 &  b, UInt8  shift  )

constexprnoexcept

Definition at line 2664 of file daw_uint_types.h.

operator^() [1/23]

constexpr UInt16 daw::operator^ ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1281 of file daw_uint_types.h.

operator^() [2/23]

constexpr UInt32 daw::operator^ ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 970 of file daw_uint_types.h.

operator^() [3/23]

constexpr UInt64 daw::operator^ ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 362 of file daw_uint_types.h.

operator^() [4/23]

constexpr UInt8 daw::operator^ ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2834 of file daw_uint_types.h.

operator^() [5/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1275 of file daw_uint_types.h.

operator^() [6/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1379 of file daw_uint_types.h.

operator^() [7/23]

constexpr UInt32 daw::operator^ ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1065 of file daw_uint_types.h.

operator^() [8/23]

constexpr UInt64 daw::operator^ ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 657 of file daw_uint_types.h.

operator^() [9/23]

constexpr UInt16 daw::operator^ ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1384 of file daw_uint_types.h.

operator^() [10/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 964 of file daw_uint_types.h.

operator^() [11/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1055 of file daw_uint_types.h.

operator^() [12/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1050 of file daw_uint_types.h.

operator^() [13/23]

constexpr UInt64 daw::operator^ ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 652 of file daw_uint_types.h.

operator^() [14/23]

constexpr UInt32 daw::operator^ ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1060 of file daw_uint_types.h.

operator^() [15/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 357 of file daw_uint_types.h.

operator^() [16/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 642 of file daw_uint_types.h.

operator^() [17/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 637 of file daw_uint_types.h.

operator^() [18/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 632 of file daw_uint_types.h.

operator^() [19/23]

constexpr UInt64 daw::operator^ ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 647 of file daw_uint_types.h.

operator^() [20/23]

constexpr UInt8 daw::operator^ ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2828 of file daw_uint_types.h.

operator^() [21/23]

constexpr UInt32 daw::operator^ ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1070 of file daw_uint_types.h.

operator^() [22/23]

constexpr UInt64 daw::operator^ ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 662 of file daw_uint_types.h.

operator^() [23/23]

constexpr UInt8 daw::operator^ ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2874 of file daw_uint_types.h.

operator^=() [1/14]

constexpr UInt16 & daw::operator^= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1229 of file daw_uint_types.h.

operator^=() [2/14]

constexpr UInt16 & daw::operator^= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1237 of file daw_uint_types.h.

operator^=() [3/14]

constexpr UInt16 & daw::operator^= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1244 of file daw_uint_types.h.

operator^=() [4/14]

constexpr UInt32 & daw::operator^= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 875 of file daw_uint_types.h.

operator^=() [5/14]

constexpr UInt32 & daw::operator^= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 890 of file daw_uint_types.h.

operator^=() [6/14]

constexpr UInt32 & daw::operator^= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 883 of file daw_uint_types.h.

operator^=() [7/14]

constexpr UInt32 & daw::operator^= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 897 of file daw_uint_types.h.

operator^=() [8/14]

constexpr UInt64 & daw::operator^= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 302 of file daw_uint_types.h.

operator^=() [9/14]

constexpr UInt64 & daw::operator^= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 323 of file daw_uint_types.h.

operator^=() [10/14]

constexpr UInt64 & daw::operator^= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 316 of file daw_uint_types.h.

operator^=() [11/14]

constexpr UInt64 & daw::operator^= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 309 of file daw_uint_types.h.

operator^=() [12/14]

constexpr UInt64 & daw::operator^= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 330 of file daw_uint_types.h.

operator^=() [13/14]

constexpr UInt8 & daw::operator^= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2741 of file daw_uint_types.h.

operator^=() [14/14]

constexpr UInt8 & daw::operator^= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2749 of file daw_uint_types.h.

operator|() [1/23]

constexpr UInt16 daw::operator| ( std::uint16_t  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1257 of file daw_uint_types.h.

operator|() [2/23]

constexpr UInt32 daw::operator| ( std::uint32_t  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 946 of file daw_uint_types.h.

operator|() [3/23]

constexpr UInt64 daw::operator| ( std::uint64_t  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 342 of file daw_uint_types.h.

operator|() [4/23]

constexpr UInt8 daw::operator| ( std::uint8_t  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2810 of file daw_uint_types.h.

operator|() [5/23]

constexpr UInt16 daw::operator| ( UInt16  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1251 of file daw_uint_types.h.

operator|() [6/23]

constexpr UInt16 daw::operator| ( UInt16  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1359 of file daw_uint_types.h.

operator|() [7/23]

constexpr UInt32 daw::operator| ( UInt16  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1015 of file daw_uint_types.h.

operator|() [8/23]

constexpr UInt64 daw::operator| ( UInt16  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 587 of file daw_uint_types.h.

operator|() [9/23]

constexpr UInt16 daw::operator| ( UInt16  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1364 of file daw_uint_types.h.

operator|() [10/23]

constexpr UInt32 daw::operator| ( UInt32  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 940 of file daw_uint_types.h.

operator|() [11/23]

constexpr UInt32 daw::operator| ( UInt32  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1005 of file daw_uint_types.h.

operator|() [12/23]

constexpr UInt32 daw::operator| ( UInt32  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1000 of file daw_uint_types.h.

operator|() [13/23]

constexpr UInt64 daw::operator| ( UInt32  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 582 of file daw_uint_types.h.

operator|() [14/23]

constexpr UInt32 daw::operator| ( UInt32  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1010 of file daw_uint_types.h.

operator|() [15/23]

constexpr UInt64 daw::operator| ( UInt64  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 337 of file daw_uint_types.h.

operator|() [16/23]

constexpr UInt64 daw::operator| ( UInt64  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 572 of file daw_uint_types.h.

operator|() [17/23]

constexpr UInt64 daw::operator| ( UInt64  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 567 of file daw_uint_types.h.

operator|() [18/23]

constexpr UInt64 daw::operator| ( UInt64  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 562 of file daw_uint_types.h.

operator|() [19/23]

constexpr UInt64 daw::operator| ( UInt64  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 577 of file daw_uint_types.h.

operator|() [20/23]

constexpr UInt8 daw::operator| ( UInt8  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2804 of file daw_uint_types.h.

operator|() [21/23]

constexpr UInt32 daw::operator| ( UInt8  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 1020 of file daw_uint_types.h.

operator|() [22/23]

constexpr UInt64 daw::operator| ( UInt8  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 592 of file daw_uint_types.h.

operator|() [23/23]

constexpr UInt8 daw::operator| ( UInt8  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2864 of file daw_uint_types.h.

operator|=() [1/14]

constexpr UInt16 & daw::operator|= ( UInt16 &  lhs, std::uint16_t  rhs  )

constexprnoexcept

Definition at line 1185 of file daw_uint_types.h.

operator|=() [2/14]

constexpr UInt16 & daw::operator|= ( UInt16 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 1193 of file daw_uint_types.h.

operator|=() [3/14]

constexpr UInt16 & daw::operator|= ( UInt16 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 1200 of file daw_uint_types.h.

operator|=() [4/14]

constexpr UInt32 & daw::operator|= ( UInt32 &  lhs, std::uint32_t  rhs  )

constexprnoexcept

Definition at line 817 of file daw_uint_types.h.

operator|=() [5/14]

constexpr UInt32 & daw::operator|= ( UInt32 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 832 of file daw_uint_types.h.

operator|=() [6/14]

constexpr UInt32 & daw::operator|= ( UInt32 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 825 of file daw_uint_types.h.

operator|=() [7/14]

constexpr UInt32 & daw::operator|= ( UInt32 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 839 of file daw_uint_types.h.

operator|=() [8/14]

constexpr UInt64 & daw::operator|= ( UInt64 &  lhs, std::uint64_t  rhs  )

constexprnoexcept

Definition at line 232 of file daw_uint_types.h.

operator|=() [9/14]

constexpr UInt64 & daw::operator|= ( UInt64 &  lhs, UInt16  rhs  )

constexprnoexcept

Definition at line 253 of file daw_uint_types.h.

operator|=() [10/14]

constexpr UInt64 & daw::operator|= ( UInt64 &  lhs, UInt32  rhs  )

constexprnoexcept

Definition at line 246 of file daw_uint_types.h.

operator|=() [11/14]

constexpr UInt64 & daw::operator|= ( UInt64 &  lhs, UInt64  rhs  )

constexprnoexcept

Definition at line 239 of file daw_uint_types.h.

operator|=() [12/14]

constexpr UInt64 & daw::operator|= ( UInt64 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 260 of file daw_uint_types.h.

operator|=() [13/14]

constexpr UInt8 & daw::operator|= ( UInt8 &  lhs, std::uint8_t  rhs  )

constexprnoexcept

Definition at line 2711 of file daw_uint_types.h.

operator|=() [14/14]

constexpr UInt8 & daw::operator|= ( UInt8 &  lhs, UInt8  rhs  )

constexprnoexcept

Definition at line 2719 of file daw_uint_types.h.

operator~() [1/4]

constexpr UInt16 daw::operator~ ( UInt16  value )

constexpr

Definition at line 2441 of file daw_uint_types.h.

operator~() [2/4]

constexpr UInt32 daw::operator~ ( UInt32  value )

constexpr

Definition at line 2157 of file daw_uint_types.h.

operator~() [3/4]

constexpr UInt64 daw::operator~ ( UInt64  value )

constexpr

Definition at line 1773 of file daw_uint_types.h.

operator~() [4/4]

constexpr UInt8 daw::operator~ ( UInt8  value )

constexpr

Definition at line 2638 of file daw_uint_types.h.

or_all() [1/3]

constexpr auto daw::or_all ( )

constexprnoexcept

Definition at line 393 of file daw_utility.h.

or_all() [2/3]

template<typename Value >

constexpr Value daw::or_all ( Value  value )

constexprnoexcept

Definition at line 398 of file daw_utility.h.

or_all() [3/3]

template<typename Value , typename... T>

constexpr decltype(auto) daw::or_all ( Value  value, T...  values  )

constexprnoexcept

Definition at line 403 of file daw_utility.h.

overload()

template<typename... Funcs>

daw::overload

(

Funcs &&

...

)

-> overload< conditional_t< std::is_class_v< daw::remove_cvref_t< Funcs > >, daw::remove_cvref_t< Funcs >, Funcs >... >

pack_apply()

template<typename Function , typename... Args>

constexpr void daw::pack_apply ( std::size_t  N, Function &&  func, Args &&...  args  )

constexpr

Definition at line 913 of file daw_utility.h.

pack_get()

template<size_t N, std::size_t pos = 0, typename Arg , typename... Args>

constexpr decltype(auto) daw::pack_get ( Arg &&  arg, Args &&...  args  )

constexprnoexcept

Definition at line 881 of file daw_utility.h.

pop_value() [1/2]

template<typename T , typename BitStream >

auto daw::pop_value

(

BitStream &

bs

)

Definition at line 101 of file daw_bit_stream.h.

pop_value() [2/2]

template<typename T , typename BitStream >

auto daw::pop_value	(	BitStream &	bs,
		size_t	bits_needed
	)

Definition at line 81 of file daw_bit_stream.h.

prev()

template<typename Iterator >

constexpr Iterator daw::prev ( Iterator  it, ptrdiff_t  n = 1  )

constexprnoexcept

Move iterator backward n steps, if n > 0, only defined for types that are Bidirectional.

Template Parameters

Iterator

Type of iterator to move backward

Parameters

it	Iterator to advance
n	how far to move backward

Returns

The resulting iterator of advancing it n steps

Definition at line 139 of file cpp_17_iterator.h.

print() [1/3]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::print	(	FILE *	fout,
		std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 21 of file daw_print.h.

print() [2/3]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::print	(	std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 36 of file daw_print.h.

print() [3/3]

template<typename... Args>

std::ostream & daw::print	(	std::ostream &	os,
		std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 22 of file daw_print_ostream.h.

println() [1/4]

DAW_ATTRIB_INLINE void daw::println

(

)

Definition at line 73 of file daw_print.h.

println() [2/4]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::println	(	FILE *	f,
		std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 47 of file daw_print.h.

println() [3/4]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::println	(	std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 61 of file daw_print.h.

println() [4/4]

template<typename... Args>

std::ostream & daw::println	(	std::ostream &	os,
		std::format_string< Args... >	fmt,
		Args &&...	args
	)

Definition at line 33 of file daw_print_ostream.h.

quick_sort()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::quick_sort ( RandomIterator  f, RandomIterator  l, Compare  cmp = Compare{ }  )

constexpr

Definition at line 57 of file daw_stack_quick_sort.h.

randint() [1/2]

template<typename IntType >

IntType daw::randint ( )

inline

Definition at line 48 of file daw_random.h.

randint() [2/2]

template<typename IntType >

IntType daw::randint ( IntType  a, IntType  b  )

inline

Definition at line 36 of file daw_random.h.

random_fill()

template<typename IntType , typename ItValueType = IntType, typename ForwardIterator >

void daw::random_fill ( ForwardIterator  first, ForwardIterator const  last, IntType  a, IntType  b  )

inline

Definition at line 73 of file daw_random.h.

read_file() [1/2]

template<typename CharT = char>

DAW_ATTRIB_NOINLINE std::optional< std::basic_string< CharT > > daw::read_file ( std::string const &  path )

noexcept

Definition at line 27 of file daw_read_file.h.

read_file() [2/2]

std::string daw::read_file ( std::string const &  path, terminate_on_read_file_error_t    )

inlinenoexcept

Definition at line 62 of file daw_read_file.h.

ref() [1/2]

template<typename T , typename = void>

auto daw::ref

(

T const &

value

)

Definition at line 76 of file daw_reference.h.

ref() [2/2]

template<typename T >

auto daw::ref

(

T const *

value

)

Definition at line 71 of file daw_reference.h.

repeat_n_char_end()

template<typename T = char>

constexpr auto daw::repeat_n_char_end ( )

constexprnoexcept

Definition at line 105 of file daw_repeat_n_char_iterator.h.

repeat_n_char_iterator()

template<typename CharT >

daw::repeat_n_char_iterator	(	size_t	,
		CharT
	)		-> repeat_n_char_iterator< CharT >

reseed() [1/2]

void daw::reseed ( )

inline

Definition at line 52 of file daw_random.h.

reseed() [2/2]

void daw::reseed ( std::default_random_engine::result_type  value )

inline

Definition at line 56 of file daw_random.h.

return_buffer()

template<typename T >

void daw::return_buffer ( T *  ptr )

inlinenoexcept

Definition at line 948 of file daw_utility.h.

reverse_iterator()

template<typename Iterator >

daw::reverse_iterator

(

Iterator

)

-> reverse_iterator< Iterator >

reverse_topological_sorted_walk() [1/2]

template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>

void daw::reverse_topological_sorted_walk	(	daw::graph_t< T > &	known_deps,
		Func	visitor,
		Compare &&	comp = Compare{ }
	)

Definition at line 513 of file daw_graph_algorithm.h.

reverse_topological_sorted_walk() [2/2]

template<typename T , typename Func , typename Compare = daw::graph_alg_impl::NoSort>

void daw::reverse_topological_sorted_walk	(	daw::graph_t< T > const &	known_deps,
		Func	visitor,
		Compare &&	comp = Compare{ }
	)

Definition at line 493 of file daw_graph_algorithm.h.

ring_adaptor()

template<typename T >

daw::ring_adaptor

(

T const &

)

-> ring_adaptor< T >

rotate_left() [1/8]

template<unsigned bits>

constexpr UInt16 daw::rotate_left ( UInt16  value )

constexpr

Definition at line 2446 of file daw_uint_types.h.

rotate_left() [2/8]

constexpr UInt16 daw::rotate_left ( UInt16  value, unsigned  bits  )

constexpr

Definition at line 2452 of file daw_uint_types.h.

rotate_left() [3/8]

template<unsigned bits>

constexpr UInt32 daw::rotate_left ( UInt32  value )

constexpr

Definition at line 1076 of file daw_uint_types.h.

rotate_left() [4/8]

constexpr UInt32 daw::rotate_left ( UInt32  value, unsigned  bits  )

constexpr

Definition at line 1081 of file daw_uint_types.h.

rotate_left() [5/8]

template<unsigned bits>

constexpr UInt64 daw::rotate_left ( UInt64  value )

constexpr

Definition at line 668 of file daw_uint_types.h.

rotate_left() [6/8]

constexpr UInt64 daw::rotate_left ( UInt64  value, unsigned  bits  )

constexpr

Definition at line 673 of file daw_uint_types.h.

rotate_left() [7/8]

template<unsigned bits>

constexpr UInt8 daw::rotate_left ( UInt8  value )

constexpr

Definition at line 2931 of file daw_uint_types.h.

rotate_left() [8/8]

constexpr UInt8 daw::rotate_left ( UInt8  value, unsigned  bits  )

constexpr

Definition at line 2937 of file daw_uint_types.h.

rotate_right() [1/8]

template<unsigned bits>

constexpr UInt16 daw::rotate_right ( UInt16  value )

constexpr

Definition at line 2457 of file daw_uint_types.h.

rotate_right() [2/8]

constexpr UInt16 daw::rotate_right ( UInt16  value, unsigned  bits  )

constexpr

Definition at line 2463 of file daw_uint_types.h.

rotate_right() [3/8]

template<unsigned bits>

constexpr UInt32 daw::rotate_right ( UInt32  value )

constexpr

Definition at line 1086 of file daw_uint_types.h.

rotate_right() [4/8]

constexpr UInt32 daw::rotate_right ( UInt32  value, unsigned  bits  )

constexpr

Definition at line 1091 of file daw_uint_types.h.

rotate_right() [5/8]

template<unsigned bits>

constexpr UInt64 daw::rotate_right ( UInt64  value )

constexpr

Definition at line 678 of file daw_uint_types.h.

rotate_right() [6/8]

constexpr UInt64 daw::rotate_right ( UInt64  value, unsigned  bits  )

constexpr

Definition at line 683 of file daw_uint_types.h.

rotate_right() [7/8]

template<unsigned bits>

constexpr UInt8 daw::rotate_right ( UInt8  value )

constexpr

Definition at line 2943 of file daw_uint_types.h.

rotate_right() [8/8]

constexpr UInt8 daw::rotate_right ( UInt8  value, unsigned  bits  )

constexpr

Definition at line 2949 of file daw_uint_types.h.

RunIfValid()

template<typename T >

auto daw::RunIfValid

(

std::weak_ptr< T >

w_ptr

)

Definition at line 354 of file daw_utility.h.

safe_advance() [1/2]

template<typename Container , typename Iterator , typename Distance >

constexpr void daw::safe_advance ( Container &  container, Iterator &  it, Distance  distance  )

constexprnoexcept

Advance Iterator within the bounds of container.

Template Parameters

Container	Container type who's iterators are of type Iterator
Iterator	Iterator pointing to members of container.

Parameters

container	container to set bounds on iterator
it	iterator to move. It is undefined behavior if iterator is outside the range [std::begin(container), std::end(container)]
distance	how far to move

Definition at line 140 of file daw_algorithm.h.

safe_advance() [2/2]

template<typename Container , typename Iterator , typename Distance >

constexpr void daw::safe_advance ( Container const &  container, Iterator &  it, Distance  distance  )

constexprnoexcept

Advance Iterator within the bounds of container.

Template Parameters

Container	Container type who's iterators are of type Iterator
Iterator	Iterator pointing to members of container.

Parameters

container	container to set bounds on iterator
it	iterator to move. It is undefined behavior if iterator is outside the range [std::begin(container), std::end(container)]
distance	how far to move

Definition at line 161 of file daw_algorithm.h.

safe_next()

template<typename Iterator , typename Distance = size_t>

constexpr Iterator daw::safe_next ( Iterator  it, Iterator const  last, Distance  n = 1U  )

constexprnoexcept

Advance iterator n steps forward but do not go past last. Undefined if it > last.

Template Parameters

Iterator

Type of Iterator to advance

Parameters

it	iterator to advance
last	boundary for it
n	number of steps to advance forwards

Returns

The resulting iterator advanced n steps

Definition at line 183 of file daw_algorithm.h.

safe_prev()

template<typename Iterator , typename Distance >

constexpr Iterator daw::safe_prev ( Iterator  it, Iterator  first, Distance  n = 1  )

constexprnoexcept

Advance iterator n steps backward but do not go past first. Undefined if it < first.

Template Parameters

Iterator

Type of Iterator to advance

Parameters

it	iterator to advance
first	boundary for it
n	number of steps to advance backwards

Returns

The resulting iterator advanced n steps

Definition at line 201 of file daw_algorithm.h.

set_bit() [1/4]

template<unsigned N>

constexpr void daw::set_bit ( UInt16 &  value, bool  state  )

inlineconstexpr

Definition at line 2906 of file daw_uint_types.h.

set_bit() [2/4]

template<unsigned N>

constexpr void daw::set_bit ( UInt32 &  value, bool  state  )

inlineconstexpr

Definition at line 2893 of file daw_uint_types.h.

set_bit() [3/4]

template<unsigned N>

constexpr void daw::set_bit ( UInt64 &  value, bool  state  )

inlineconstexpr

Definition at line 2880 of file daw_uint_types.h.

set_bit() [4/4]

template<unsigned N>

constexpr void daw::set_bit ( UInt8 &  value, bool  state  )

inlineconstexpr

Definition at line 2919 of file daw_uint_types.h.

set_bits()

template<typename Integer , typename Bit , typename... Bits>

constexpr Integer daw::set_bits ( Integer  i, Bit  b, Bits...  bs  )

constexprnoexcept

set bits at positions specified by b,bs...

Definition at line 78 of file daw_bit.h.

show_benchmark()

template<typename Func >

DAW_ATTRIB_NOINLINE void daw::show_benchmark	(	size_t	data_size_bytes,
		std::string const &	title,
		Func &&	func,
		size_t	data_prec = 1,
		size_t	time_prec = 0,
		size_t	item_count = 1
	)

Definition at line 117 of file daw_benchmark.h.

shuffle()

template<typename RandomIterator >

void daw::shuffle ( RandomIterator  first, RandomIterator  last  )

inline

Definition at line 61 of file daw_random.h.

signbit()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>

DAW_ATTRIB_INLINE constexpr bool daw::signbit ( T  t )

constexpr

Definition at line 102 of file daw_int_cmp.h.

simple_array()

template<typename T , typename... Ts>

daw::simple_array	(	T &&	,
		Ts &&	...
	)		-> simple_array< T, sizeof...(Ts)+1 >

siphash24()

template<typename Byte >

constexpr uint64_t daw::siphash24 ( Byte const *  first, size_t  sz, Byte const *const  key  )

constexpr

Definition at line 85 of file daw_sip_hash.h.

size()

template<typename Container >

constexpr auto daw::size ( Container const &  c ) -> decltype( c.size( ) )

constexprnoexcept

Definition at line 117 of file cpp_17.h.

skip_bits()

template<typename BitStream >

void daw::skip_bits	(	BitStream &	bs,
		size_t	bits_needed
	)

Definition at line 106 of file daw_bit_stream.h.

skip_bytes()

template<typename BitStream >

void daw::skip_bytes	(	BitStream &	bs,
		size_t	bytes_needed
	)

Definition at line 116 of file daw_bit_stream.h.

skip_until() [1/2]

template<typename BitStream , typename TestValue >

void daw::skip_until	(	BitStream &	bs,
		TestValue const &	v
	)

Definition at line 137 of file daw_bit_stream.h.

skip_until() [2/2]

template<typename BitStream , typename TestValue >

void daw::skip_until	(	BitStream &	bs,
		TestValue const &	v,
		size_t	bit_count
	)

Definition at line 121 of file daw_bit_stream.h.

sort()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort ( RandomIterator  first, RandomIterator  last, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 563 of file daw_sort_n.h.

sort_16()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_16 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 275 of file daw_sort_n.h.

sort_3()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_3 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 339 of file daw_sort_n.h.

sort_32()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_32 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 59 of file daw_sort_n.h.

sort_4()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_4 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 347 of file daw_sort_n.h.

sort_5()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_5 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 357 of file daw_sort_n.h.

sort_6()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_6 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 370 of file daw_sort_n.h.

sort_7()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_7 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 387 of file daw_sort_n.h.

sort_8()

template<typename RandomIterator , typename Compare = std::less<>>

constexpr void daw::sort_8 ( RandomIterator  first, Compare &&  comp = Compare{ }  )

constexprnoexcept

Definition at line 408 of file daw_sort_n.h.

sort_to() [1/2]

template<typename ForwardIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< std::is_integral_v< typename std::iterator_traits< ForwardIterator >::value_type >, std::nullptr_t > = nullptr>

constexpr RandomOutputIterator daw::sort_to ( ForwardIterator  first_in, ForwardIterator  last_in, RandomOutputIterator  first_out, Compare &&  comp = Compare{ }  )

constexpr

Definition at line 793 of file daw_sort_n.h.

sort_to() [2/2]

template<typename InputIterator , typename RandomOutputIterator , typename Compare = std::less<>, std::enable_if_t< not std::is_integral_v< typename std::iterator_traits< InputIterator >::value_type >, std::nullptr_t > = nullptr>

constexpr RandomOutputIterator daw::sort_to ( InputIterator  first_in, InputIterator  last_in, RandomOutputIterator  first_out, Compare &&  comp = Compare{ }  )

constexpr

Definition at line 738 of file daw_sort_n.h.

span() [1/10]

template<typename Container >

daw::span

(

Container &

)

-> span< std::remove_reference_t< decltype(*std::data(std::declval< Container >()))> >

span() [2/10]

template<typename Container >

daw::span

(

Container const &

)

-> span< DAW_TYPEOF(*std::data(std::declval< Container >())) const >

span() [3/10]

template<typename T >

daw::span	(	T *	,
		size_t
	)		-> span< T >

span() [4/10]

template<typename T >

daw::span	(	T *	,
		T *
	)		-> span< T >

span() [5/10]

template<typename T >

daw::span	(	T *	,
		T const *
	)		-> span< T >

span() [6/10]

template<typename T , size_t N>

daw::span

(

T

const(&)[N]

)

-> span< T const >

span() [7/10]

template<typename T >

daw::span	(	T const *	,
		size_t
	)		-> span< T const >

span() [8/10]

template<typename T >

daw::span	(	T const *	,
		T *
	)		-> span< T const >

span() [9/10]

template<typename T >

daw::span	(	T const *	,
		T const *
	)		-> span< T const >

span() [10/10]

template<typename T , size_t N>

daw::span

(

T(&)

[N]

)

-> span< T >

split() [1/6]

template<typename CharT , size_t Capacity, size_t N>

auto daw::split ( daw::basic_bounded_string< CharT, Capacity > &&  str, CharT const (&)  delemiter[N]  )

delete

split() [2/6]

template<typename CharT , size_t Capacity>

auto daw::split ( daw::basic_bounded_string< CharT, Capacity > &&  str, CharT const  delemiter  )

delete

split() [3/6]

template<typename CharT , size_t Capacity, size_t N>

auto daw::split	(	daw::basic_bounded_string< CharT, Capacity > const &	str,
		CharT const (&)	delemiter[N]
	)

Definition at line 1323 of file daw_bounded_string.h.

split() [4/6]

template<typename CharT , size_t Capacity>

auto daw::split	(	daw::basic_bounded_string< CharT, Capacity > const &	str,
		CharT const	delemiter
	)

Definition at line 1311 of file daw_bounded_string.h.

split() [5/6]

template<typename CharT , size_t N, typename UnaryPredicate >

auto daw::split ( daw::basic_bounded_string< CharT, N > &&  str, UnaryPredicate  pred  )

delete

split() [6/6]

template<typename CharT , size_t N, typename UnaryPredicate >

auto daw::split	(	daw::basic_bounded_string< CharT, N > const &	str,
		UnaryPredicate	pred
	)

Definition at line 1295 of file daw_bounded_string.h.

split_args()

template<std::size_t StartN, std::size_t EndN, typename... Args, std::enable_if_t<(sizeof...(Args) >=EndN), std::nullptr_t > = nullptr>

constexpr auto daw::split_args ( std::tuple< Args... >  args )

constexpr

Definition at line 41 of file daw_bind_args_at.h.

split_args_impl()

template<std::size_t StartN, typename... Args, std::size_t... Is, std::enable_if_t<(sizeof...(Args) >=(sizeof...(Is)+StartN)), std::nullptr_t > = nullptr>

constexpr auto daw::split_args_impl ( std::tuple< Args... > &&  args, std::index_sequence< Is... >    )

constexpr

Definition at line 28 of file daw_bind_args_at.h.

split_string() [1/6]

template<typename CharT , typename Bounds = daw::sv1::default_string_view_bounds_type, size_t N, size_t M>

constexpr string_split_range< CharT > daw::split_string ( CharT const (&)  str[N], CharT const (&)  delemiter[M]  )

constexprnoexcept

Definition at line 201 of file daw_string_split_range.h.

split_string() [2/6]

template<typename CharT >

constexpr string_split_range< CharT > daw::split_string ( daw::sv1::basic_string_view< CharT >  str, daw::sv1::basic_string_view< CharT >  delemiter  )

constexprnoexcept

Definition at line 170 of file daw_string_split_range.h.

split_string() [3/6]

template<typename CharT , typename Bounds , std::ptrdiff_t Ex, size_t N>

constexpr string_split_range< CharT > daw::split_string ( daw::sv1::basic_string_view< CharT, Bounds, Ex >  str, CharT const (&)  delemiter[N]  )

constexprnoexcept

Definition at line 178 of file daw_string_split_range.h.

split_string() [4/6]

template<typename CharT , daw::sv2::string_view_bounds_type Bounds, std::ptrdiff_t Ex, size_t N>

constexpr string_split_range< CharT > daw::split_string ( daw::sv2::basic_string_view< CharT, Bounds >  str, CharT const (&)  delemiter[N]  )

constexprnoexcept

Definition at line 190 of file daw_string_split_range.h.

split_string() [5/6]

template<typename CharT >

string_split_range< CharT > daw::split_string ( std::basic_string< CharT > const &  str, daw::sv1::basic_string_view< CharT >  delemiter  )

noexcept

Definition at line 153 of file daw_string_split_range.h.

split_string() [6/6]

template<typename CharT >

string_split_range< CharT > daw::split_string ( std::basic_string< CharT > const &  str, std::basic_string< CharT > &  delemiter  )

noexcept

Definition at line 161 of file daw_string_split_range.h.

string_concat()

template<typename... Strings>

std::string daw::string_concat ( std::string  arg, Strings &&...  strings  )

inline

Definition at line 150 of file daw_string_concat.h.

string_split_iterator()

template<typename CharT >

daw::string_split_iterator	(	daw::sv1::basic_string_view< CharT >	,
		daw::sv1::basic_string_view< CharT >
	)		-> string_split_iterator< CharT >

string_split_range()

template<typename CharT >

daw::string_split_range	(	daw::sv1::basic_string_view< CharT >	,
		daw::sv1::basic_string_view< CharT >
	)		-> string_split_range< CharT >

swap() [1/14]

template<typename CharT , size_t N>

constexpr void daw::swap ( basic_bounded_string< CharT, N > &  lhs, basic_bounded_string< CharT, N > &  rhs  )

constexprnoexcept

Definition at line 748 of file daw_bounded_string.h.

swap() [2/14]

template<typename T , size_t N>

constexpr void daw::swap ( carray< T, N > &  lhs, carray< T, N > &  rhs  )

constexprnoexcept

Definition at line 226 of file daw_carray.h.

swap() [3/14]

template<class T1 , class T2 >

constexpr void daw::swap ( compressed_pair< T1, T2 > &  x, compressed_pair< T1, T2 > &  y  )

constexprnoexcept

Definition at line 167 of file compressed_pair.h.

swap() [4/14]

template<typename T , typename Deleter >

constexpr void daw::swap ( copiable_unique_ptr< T, Deleter > &  lhs, copiable_unique_ptr< T, Deleter > &  rhs  )

constexprnoexcept

Definition at line 128 of file daw_copiable_unique_ptr.h.

swap() [5/14]

template<typename... Args>

void daw::swap ( CString< Args... > &  lhs, CString< Args... > &  rhs  )

noexcept

Definition at line 165 of file daw_cstring.h.

swap() [6/14]

template<typename T >

constexpr void daw::swap ( daw::heap_array< T > &  lhs, daw::heap_array< T > &  rhs  )

constexprnoexcept

Definition at line 231 of file daw_heap_array.h.

swap() [7/14]

template<typename T >

void daw::swap ( daw::optional_poly< T > &  lhs, daw::optional_poly< T > &  rhs  )

noexcept

Definition at line 170 of file daw_optional_poly.h.

swap() [8/14]

template<typename T >

void daw::swap ( hash_table< T > &  lhs, hash_table< T > &  rhs  )

noexcept

Definition at line 676 of file daw_hash_table.h.

swap() [9/14]

template<typename T >

void daw::swap ( hash_table_item_iterator< T > &  lhs, hash_table_item_iterator< T > &  rhs  )

noexcept

Definition at line 292 of file daw_hash_table.h.

swap() [10/14]

template<typename T >

void daw::swap ( heap_value< T > &  lhs, heap_value< T > &  rhs  )

noexcept

Definition at line 119 of file deprecated/daw_heap_value.h.

swap() [11/14]

template<typename T , typename D >

constexpr void daw::swap ( rc_ptr< T, D > &  lhs, rc_ptr< T, D > &  rhs  )

constexpr

Definition at line 401 of file daw_ref_counted_pointer.h.

swap() [12/14]

template<class T , class Allocator >

constexpr void daw::swap ( split_buffer< T, Allocator > &  x, split_buffer< T, Allocator > &  y  )

inlineconstexprnoexcept

Definition at line 535 of file split_buffer.h.

swap() [13/14]

template<typename T >

constexpr void daw::swap ( value_ptr< T > &  lhs, value_ptr< T > &  rhs  )

constexprnoexcept

Definition at line 216 of file daw_value_ptr.h.

swap() [14/14]

template<typename T , typename Allocator >

constexpr void daw::swap ( vector< T, Allocator > &  x, vector< T, Allocator > &  y  )

constexprnoexcept

Definition at line 1289 of file vector.h.

swap_ranges()

template<typename ForwardIterator1 , typename ForwardIterator2 >

constexpr ForwardIterator2 daw::swap_ranges ( ForwardIterator1  first1, ForwardIterator1  last1, ForwardIterator2  first2  )

constexprnoexcept

Definition at line 78 of file daw_swap.h.

take()

template<typename T , std::enable_if_t< std::is_default_constructible_v< T >, std::nullptr_t > = nullptr>

constexpr T daw::take ( T &  value )

constexprnoexcept

Definition at line 31 of file daw_take.h.

tie()

template<typename... Ts>

constexpr tuple< Ts &... > daw::tie ( Ts &...  ts )

constexprnoexcept

Definition at line 230 of file daw_tuple.h.

to_address() [1/2]

template<typename T >

constexpr T * daw::to_address ( T *  p )

constexprnoexcept

Definition at line 78 of file cpp_20.h.

to_address() [2/2]

template<typename T >

constexpr auto daw::to_address ( T const &  p )

constexprnoexcept

Definition at line 84 of file cpp_20.h.

to_array()

template<typename T , std::size_t N>

constexpr std::array< std::remove_cv_t< T >, N > daw::to_array ( T(&)  a[N] )

constexpr

Definition at line 31 of file daw_array.h.

to_array_of()

template<typename To , typename From >

auto daw::to_array_of ( From &&  from )

noexcept

Definition at line 789 of file daw_utility.h.

to_big_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr T daw::to_big_endian ( T  value )

constexprnoexcept

Definition at line 124 of file daw_endian.h.

to_little_endian()

template<typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr T daw::to_little_endian ( T  value )

constexprnoexcept

Definition at line 114 of file daw_endian.h.

to_native_endian()

template<endian SourceEndian, typename T , std::enable_if_t< daw::is_integral_v< T >, std::nullptr_t > = nullptr>

constexpr T daw::to_native_endian ( T  value )

constexprnoexcept

Definition at line 144 of file daw_endian.h.

to_os_string_int()

template<typename CharT , typename OutputIterator , typename Integer , typename Traits = daw::impl::char_traits<CharT>, std::enable_if_t< can_to_os_string_int_v< daw::remove_cvref_t< Integer > >, std::nullptr_t > = nullptr>

constexpr OutputIterator daw::to_os_string_int ( OutputIterator  it, Integer  value  )

constexpr

Definition at line 229 of file daw_int_to_iterator.h.

to_reference_vector()

template<typename Iterator >

auto daw::to_reference_vector	(	Iterator	first,
		Iterator	last
	)

Definition at line 81 of file daw_reference.h.

to_string() [1/2]

template<typename Char >

std::string daw::to_string

(

CString< Char > const &

str

)

Definition at line 171 of file daw_cstring.h.

to_string() [2/2]

template<size_t BitWidth>

std::string daw::to_string ( static_bitset< BitWidth > const &  bs )

inline

Definition at line 531 of file daw_static_bitset.h.

to_uint16()

template<typename Number >

constexpr UInt16 daw::to_uint16 ( Number  num )

constexpr

Definition at line 43 of file daw_uint_types.h.

to_uint16_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>

constexpr UInt16 daw::to_uint16_buffer ( CharT const *  ptr )

constexprnoexcept

Definition at line 3038 of file daw_uint_types.h.

to_uint32()

template<typename Number >

constexpr UInt32 daw::to_uint32 ( Number  num )

constexpr

Definition at line 37 of file daw_uint_types.h.

to_uint32_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>

constexpr UInt32 daw::to_uint32_buffer ( CharT const *  ptr )

constexprnoexcept

Definition at line 3023 of file daw_uint_types.h.

to_uint64()

template<typename Number >

constexpr UInt64 daw::to_uint64 ( Number  num )

constexpr

Definition at line 31 of file daw_uint_types.h.

to_uint64_buffer()

template<typename CharT , std::enable_if_t<(sizeof(CharT)==1), std::nullptr_t > = nullptr>

constexpr UInt64 daw::to_uint64_buffer ( CharT const *  ptr )

constexprnoexcept

Definition at line 3000 of file daw_uint_types.h.

to_uint8()

template<typename Number >

constexpr UInt8 daw::to_uint8 ( Number  num )

constexpr

Definition at line 49 of file daw_uint_types.h.

to_underlying()

template<typename Enum , std::enable_if_t< std::is_enum_v< Enum >, std::nullptr_t > = nullptr>

constexpr auto daw::to_underlying ( Enum  e )

constexpr

Definition at line 16 of file daw_to_underlying_type.h.

topological_sorted_walk() [1/2]

template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>

void daw::topological_sorted_walk	(	daw::graph_t< T > &	graph,
		Function &&	func,
		Compare	comp = Compare{ }
	)

Definition at line 245 of file daw_graph_algorithm.h.

topological_sorted_walk() [2/2]

template<typename T , typename Function , typename Compare = daw::graph_alg_impl::NoSort>

void daw::topological_sorted_walk	(	daw::graph_t< T > const &	graph,
		Function &&	func,
		Compare	comp = Compare{ }
	)

Definition at line 231 of file daw_graph_algorithm.h.

try_get() [1/2]

template<typename Map , typename Key >

constexpr auto daw::try_get ( Map &  container, Key &&  k  )

constexpr

Definition at line 53 of file daw_algorithm.h.

try_get() [2/2]

template<typename Map , typename Key >

constexpr auto daw::try_get ( Map const &  container, Key &&  k  )

constexpr

Definition at line 63 of file daw_algorithm.h.

tuple()

template<typename... Ts>

daw::tuple

(

Ts...

)

-> tuple< Ts... >

tuple2()

template<typename... Ts>

daw::tuple2

(

Ts...

)

-> tuple2< Ts... >

tuple2_cat() [1/3]

constexpr tuple2 daw::tuple2_cat ( )

constexpr

Definition at line 208 of file daw_tuple2.h.

tuple2_cat() [2/3]

template<typename T0 , typename T1 , typename... Tps>

constexpr auto daw::tuple2_cat ( T0 &&  t0, T1 &&  t1, Tps &&...  tps  )

constexpr

Definition at line 218 of file daw_tuple2.h.

tuple2_cat() [3/3]

template<typename Tuple >

constexpr tuple2 daw::tuple2_cat ( Tuple &&  tp )

constexpr

Definition at line 213 of file daw_tuple2.h.

unset_bits()

template<typename Integer , typename Bit , typename... Bits>

constexpr Integer daw::unset_bits ( Integer  i, Bit  b, Bits...  bs  )

constexprnoexcept

set bits at positions specified by b,bs...

Definition at line 87 of file daw_bit.h.

value_from_chars() [1/4]

template<typename To >

constexpr uint16_t daw::value_from_chars ( unsigned char const *  ptr, std::integral_constant< size_t, sizeof(uint16_t)>    )

constexprnoexcept

Definition at line 733 of file daw_utility.h.

value_from_chars() [2/4]

template<typename To >

constexpr uint32_t daw::value_from_chars ( unsigned char const *  ptr, std::integral_constant< size_t, sizeof(uint32_t)>    )

constexprnoexcept

Definition at line 743 of file daw_utility.h.

value_from_chars() [3/4]

template<typename To >

constexpr uint64_t daw::value_from_chars ( unsigned char const *  ptr, std::integral_constant< size_t, sizeof(uint64_t)>    )

constexprnoexcept

Definition at line 757 of file daw_utility.h.

value_from_chars() [4/4]

template<typename To >

constexpr uint8_t daw::value_from_chars ( unsigned char const *  ptr, std::integral_constant< size_t, sizeof(uint8_t)>    )

constexprnoexcept

Definition at line 726 of file daw_utility.h.

value_is()

template<typename T >

constexpr auto daw::value_is ( T &&  value ) -> daw::utility_details::value_is_utility_details< std::remove_reference_t<decltype( value )>>

constexpr

Definition at line 822 of file daw_utility.h.

values_from_stream() [1/2]

template<typename... Args, typename Stream >

decltype(auto) daw::values_from_stream	(	Stream &&	s,
		daw::string_view	delemiter
	)

Extract specified argument types from a stream of character data.

Template Parameters

Args	Types of expected data to find in string
Stream	Text stream type

Parameters

s	text stream to extract values from
delemiter	split what string arguments on

Returns

A tuple of values of the types specified in Args

Definition at line 531 of file daw_parse_to.h.

values_from_stream() [2/2]

template<typename... Args, typename Stream , typename Splitter , std::enable_if_t<(not parse_to_impl::has_str_member_v< Stream > and std::is_invocable_v< Splitter, daw::string_view >), std::nullptr_t > = nullptr>

decltype(auto) daw::values_from_stream	(	Stream &&	s,
		Splitter &&	splitter
	)

Extract specified argument types from a stream of character data.

Template Parameters

Args	Types of expected data to find in string
Stream	Text stream type that does not have a str( ) method
Splitter	A predicate that will return true on the string parts to split on

Parameters

stream	text stream to extract values from
splitter	Function to split string into arguments

Returns

A tuple of values of the types specified in Args

Template Parameters

Args	Types of expected data to find in string
Stream	Text stream type, like stringstream, that has a str( ) method
Splitter	A predicate that will return true on the string parts to split on

Parameters

s	text stream to extract values from
splitter	Function to split string into arguments

Returns

A tuple of values of the types specified in Args

Definition at line 497 of file daw_parse_to.h.

variant_cast() [1/3]

template<typename T , typename... Args>

constexpr T daw::variant_cast ( std::variant< Args... > &&  var )

constexpr

Definition at line 74 of file daw_variant_cast.h.

variant_cast() [2/3]

template<typename T , typename... Args>

constexpr T daw::variant_cast ( std::variant< Args... > &  var )

constexpr

Definition at line 60 of file daw_variant_cast.h.

variant_cast() [3/3]

template<typename T , typename... Args>

constexpr T daw::variant_cast ( std::variant< Args... > const &  var )

constexpr

Definition at line 67 of file daw_variant_cast.h.

vector() [1/2]

template<input_iterator InputIterator>

daw::vector	(	InputIterator	,
		InputIterator
	)		-> vector< iter_value_type< InputIterator >, std::allocator< iter_value_type< InputIterator > > >

vector() [2/2]

template<input_iterator InputIterator, Allocators Alloc>

daw::vector	(	InputIterator	,
		InputIterator	,
		Alloc
	)		-> vector< iter_value_type< InputIterator >, Alloc >

Vector()

template<typename T , std::size_t N>

daw::Vector

(

T

const(&)[N]

)

-> Vector< T >

view()

template<typename BidirectionalIterator >

daw::view	(	BidirectionalIterator	,
		BidirectionalIterator
	)		-> view< BidirectionalIterator >

visit() [1/2]

template<typename Variant , typename... Visitors>

constexpr decltype(auto) daw::visit ( Variant &&  var, Visitors &&...  visitors  )

constexpr

Definition at line 386 of file daw_visit.h.

visit() [2/2]

template<typename Result , typename Variant , typename... Visitors>

constexpr Result daw::visit ( Variant &&  var, Visitors &&...  visitors  )

constexpr

Definition at line 401 of file daw_visit.h.

visit_nt() [1/2]

template<typename Variant , typename... Visitors>

constexpr decltype(auto) daw::visit_nt ( Variant &&  var, Visitors &&...  visitors  )

constexpr

Definition at line 373 of file daw_visit.h.

visit_nt() [2/2]

template<typename Result , typename Variant , typename... Visitors>

constexpr Result daw::visit_nt ( Variant &&  var, Visitors &&...  visitors  )

constexpr

Definition at line 414 of file daw_visit.h.

vprint() [1/2]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::vprint	(	FILE *	fout,
		std::string_view	fmt,
		Args &&...	args
	)

Definition at line 28 of file daw_print.h.

vprint() [2/2]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::vprint	(	std::string_view	fmt,
		Args &&...	args
	)

Definition at line 42 of file daw_print.h.

vprintln() [1/2]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::vprintln	(	FILE *	f,
		std::string	fmt,
		Args &&...	args
	)

Definition at line 54 of file daw_print.h.

vprintln() [2/2]

template<typename... Args>

DAW_ATTRIB_NOINLINE void daw::vprintln	(	std::string	fmt,
		Args &&...	args
	)

Definition at line 68 of file daw_print.h.

zip_container()

template<typename... Containers>

daw::zip_container

(

Containers &&

...

)

-> zip_container< Containers... >

zip_iterator()

template<typename... Iterators>

daw::zip_iterator

(

Iterators...

)

-> zip_iterator< Iterators... >

Variable Documentation

all_true_v

template<bool... values>

constexpr bool daw::all_true_v = ( values and ... )

inlineconstexpr

Definition at line 43 of file cpp_17.h.

always_false_v

template<typename... Ts>

constexpr bool daw::always_false_v = always_false<Ts...>::value

inlineconstexpr

Definition at line 20 of file daw_always_false.h.

any_of

template<auto needle, auto... needles>

constexpr any_of_t<decltype( needle ), needle, needles...> daw::any_of { }

inlinestaticconstexpr

A predicate value used in the find based routine to return true when the element is one of the specified characters.

Definition at line 38 of file daw_view_tags.h.

any_true_v

template<bool... values>

constexpr bool daw::any_true_v = ( values or ... )

inlineconstexpr

Definition at line 49 of file cpp_17.h.

bit_count_v

template<typename T >

constexpr std::size_t daw::bit_count_v = sizeof( T ) * CHAR_BIT

inlineconstexpr

Definition at line 16 of file daw_bit_count.h.

bsizeof

template<typename T >

constexpr std::size_t const daw::bsizeof

inlineconstexpr

Initial value:

=
    bit_count_v<daw::remove_cvref_t<T>>

Definition at line 941 of file daw_traits.h.

can_call_v

template<size_t N, typename Invokable , typename TpArgs , typename... Args>

constexpr bool daw::can_call_v

inlineconstexpr

Initial value:

=
    daw::is_detected_v<can_call_test, std::integral_constant<std::size_t, N>,
                       Invokable, TpArgs, Args...>

Definition at line 83 of file daw_bind_args_at.h.

can_constant_evaluate_v

template<DAW_CXEVAL_FTYPE F>

constexpr bool daw::can_constant_evaluate_v

inlineconstexpr

Initial value:

=
    can_constant_evaluate<F>::value

Definition at line 74 of file daw_can_constant_evaluate.h.

can_construct_a_v

template<typename T , typename... Args>

constexpr bool daw::can_construct_a_v

inlineconstexpr

Initial value:

=
    is_detected_v<construct_details::can_construct_a_detect, T, Args...>

Definition at line 92 of file daw_construct_a.h.

can_potentially_constant_construct_v

template<typename T , typename... Args>

constexpr bool daw::can_potentially_constant_construct_v

inlineconstexpr

Initial value:

=
    can_potentially_constant_construct<T, Args...>::value

Definition at line 92 of file daw_can_constant_evaluate.h.

can_to_os_string_int_v

template<typename Integer >

constexpr bool daw::can_to_os_string_int_v

inlineconstexpr

Initial value:

=
    daw::all_true_v<std::is_integral_v<daw::remove_cvref_t<Integer>>,
                    not std::is_same_v<bool, daw::remove_cvref_t<Integer>>,
                    not std::is_floating_point_v<daw::remove_cvref_t<Integer>>,
                    not daw::traits::is_character_v<Integer>>

Definition at line 218 of file daw_int_to_iterator.h.

conjunction_v

template<typename... Ts>

constexpr bool daw::conjunction_v

inlineconstexpr

Initial value:

=
    ( static_cast<bool>( Ts::value ) and ... )

Definition at line 33 of file cpp_17.h.

constant_v

template<decltype(auto) Value>

constexpr auto daw::constant_v = constant<Value>{ }

inlineconstexpr

Definition at line 37 of file daw_constant.h.

construct_a

template<typename T >

constexpr construct_a_t<T> daw::construct_a = construct_a_t<T>{ }

inlineconstexpr

Definition at line 82 of file daw_construct_a.h.

construct_emplace

template<typename T = void>

constexpr construct_emplace_t<T> daw::construct_emplace { }

inlineconstexpr

Definition at line 89 of file daw_poly_value.h.

construct_for_overwrite

constexpr construct_for_overwrite_t daw::construct_for_overwrite { }

inlineconstexpr

Definition at line 25 of file daw_fixed_array.h.

contract_failure_handler

constinit thread_local daw::function_ref<void( )> daw::contract_failure_handler = default_contract_failure

static

Definition at line 36 of file daw_contract.h.

deduced_false_v

template<typename... >

constexpr bool daw::deduced_false_v = false

inlineconstexpr

Definition at line 935 of file daw_traits.h.

dependent_false_v

template<typename... >

constexpr bool daw::dependent_false_v = false

inlineconstexpr

Definition at line 13 of file daw_dependent_false.h.

describe_v

template<typename T >

constexpr daw::string_view daw::describe_v = impl::describe_impl<T>( )

inlineconstexpr

Definition at line 49 of file daw_describe.h.

digits

template<typename T >

constexpr auto daw::digits = numeric_limits<T>::digits

inlineconstexpr

Definition at line 243 of file daw_arith_traits.h.

digits10

template<typename T >

constexpr auto daw::digits10 = numeric_limits<T>::digits10

inlineconstexpr

Definition at line 240 of file daw_arith_traits.h.

discard

constexpr auto daw::discard = discard_t{ }

inlineconstexpr

Definition at line 20 of file daw_view_tags.h.

disjunction_v

template<typename... Ts>

constexpr bool daw::disjunction_v

inlineconstexpr

Initial value:

=
    ( static_cast<bool>( Ts::value ) or ... )

Definition at line 157 of file cpp_17.h.

do_resize_and_overwrite

constexpr auto daw::do_resize_and_overwrite = do_resize_and_overwrite_t{ }

inlineconstexpr

Definition at line 95 of file vector.h.

dont_clip_to_bounds

constexpr auto daw::dont_clip_to_bounds = dont_clip_to_bounds_t{ }

inlineconstexpr

Definition at line 23 of file daw_view_tags.h.

DynamicExtent

constexpr auto daw::DynamicExtent = max_value<std::size_t>

inlineconstexpr

Definition at line 30 of file daw_container_traits.h.

fmt_binary

constexpr bitset_impl::fmt_binary_t const daw::fmt_binary { }

inlineconstexpr

Definition at line 103 of file daw_static_bitset.h.

fmt_decimal

constexpr bitset_impl::fmt_decimal_t const daw::fmt_decimal { }

inlineconstexpr

Definition at line 105 of file daw_static_bitset.h.

fmt_hex

constexpr bitset_impl::fmt_hex_t const daw::fmt_hex { }

inlineconstexpr

Definition at line 104 of file daw_static_bitset.h.

has_kv_mapping_v

template<typename Container >

constexpr bool daw::has_kv_mapping_v

inlineconstexpr

Initial value:

= requires {
    typename std::remove_cvref_t<Container>::key_type;
    typename std::remove_cvref_t<Container>::mapped_type;
  }

Specifies that Container has type alias members key_type and mapped_type.

Definition at line 145 of file daw_concepts.h.

has_slow_distance_v

template<typename T >

constexpr bool daw::has_slow_distance_v

inlineconstexpr

Initial value:

= requires {
    typename T::slow_distance;
  }

Definition at line 107 of file vector.h.

index_constant_v

template<std::size_t N>

constexpr index_constant<N> daw::index_constant_v = index_constant<N>{ }

inlineconstexpr

Definition at line 850 of file daw_traits.h.

is_any_of_v

template<auto Needle, auto... Haystack>

constexpr bool daw::is_any_of_v = ( ( Needle == Haystack ) or ... )

inlineconstexpr

Definition at line 13 of file daw_is_any_of.h.

is_arithmetic_v

template<typename T >

constexpr bool daw::is_arithmetic_v

inlineconstexpr

Initial value:

=
    is_number_v<T> or std::is_enum_v<T> or
    daw::numeric_limits<T>::is_specialized

Definition at line 80 of file daw_arith_traits.h.

is_ascii_alpha

constexpr auto daw::is_ascii_alpha = is_ascii_alpha_t{ }

inlineconstexpr

Definition at line 43 of file daw_ascii.h.

is_ascii_alphanum

constexpr auto daw::is_ascii_alphanum = is_ascii_alphanum_t{ }

inlineconstexpr

Definition at line 55 of file daw_ascii.h.

is_ascii_digit

constexpr auto daw::is_ascii_digit = is_ascii_digit_t{ }

inlineconstexpr

Definition at line 29 of file daw_ascii.h.

is_ascii_printable

constexpr auto daw::is_ascii_printable = is_ascii_printable_t{ }

inlineconstexpr

Definition at line 67 of file daw_ascii.h.

is_bounded_graph_node_v

template<typename T >

constexpr bool daw::is_bounded_graph_node_v = false

inlineconstexpr

Definition at line 180 of file daw_bounded_graph.h.

is_bounded_graph_node_v< bounded_graph_node_t< T, MaxVerticesPerNode, Hash > >

template<typename T , size_t MaxVerticesPerNode, typename Hash >

constexpr bool daw::is_bounded_graph_node_v< bounded_graph_node_t< T, MaxVerticesPerNode, Hash > >

inlineconstexpr

Initial value:

=
      true

Definition at line 374 of file daw_bounded_graph.h.

is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >

template<typename T , size_t MaxVerticesPerNode, typename Hash >

constexpr bool daw::is_bounded_graph_node_v< const_graph_node_t< T, MaxVerticesPerNode, Hash > >

inlineconstexpr

Initial value:

=
      true

Definition at line 264 of file daw_bounded_graph.h.

is_complete_type_v

template<typename T >

constexpr bool daw::is_complete_type_v

inlineconstexpr

Initial value:

=
    decltype( is_complete_details::is_complete_test(
      std::declval<T *>( ) ) ){ }

Definition at line 909 of file daw_traits.h.

is_daw_span_v

template<typename T >

constexpr bool const daw::is_daw_span_v = is_daw_span_t<T>::value

inlineconstexpr

Definition at line 35 of file daw_span.h.

is_deduced_type_v

template<typename T >

constexpr bool daw::is_deduced_type_v = false

inlineconstexpr

Definition at line 23 of file daw_deduced_type.h.

is_deduced_type_v< deduced_type >

template<>

constexpr bool daw::is_deduced_type_v< deduced_type > = true

inlineconstexpr

Definition at line 26 of file daw_deduced_type.h.

is_detected_convertible_v

template<typename To , template< typename... > typename Op, typename... Args>

constexpr bool daw::is_detected_convertible_v

inlineconstexpr

Initial value:

=
    is_detected_convertible<To, Op, Args...>::value

Definition at line 129 of file daw_is_detected.h.

is_detected_exact_v

template<typename Expected , template< typename... > typename Op, typename... Args>

constexpr bool daw::is_detected_exact_v

inlineconstexpr

Initial value:

=
    daw::is_same_v<Expected, detected_t<Op, Args...>>

Definition at line 116 of file daw_is_detected.h.

is_detected_v

template<template< typename... > typename Op, typename... Args>

constexpr bool daw::is_detected_v

inlineconstexpr

Initial value:

=
    is_detect_details::detector_v<Op, is_detect_details::pack_t<Args...>>

Definition at line 102 of file daw_is_detected.h.

is_empty_tuple_v

template<typename Tuple >

constexpr bool daw::is_empty_tuple_v = ( tuple_size_v<Tuple> == 0 )

inlineconstexpr

Definition at line 505 of file daw_tuple_helper.h.

is_floating_point_v

template<typename T >

constexpr bool daw::is_floating_point_v

inlineconstexpr

Initial value:

=
    not is_integral_v<T> and daw::numeric_limits<T>::is_signed and
    not daw::numeric_limits<T>::is_exact

Definition at line 36 of file daw_arith_traits.h.

is_graph_node_v

template<typename >

constexpr bool daw::is_graph_node_v = false

inlineconstexpr

Definition at line 157 of file daw_graph.h.

is_graph_node_v< const_graph_node_t< T > >

template<typename T >

constexpr bool daw::is_graph_node_v< const_graph_node_t< T > > = true

inlineconstexpr

Definition at line 238 of file daw_graph.h.

is_graph_node_v< graph_node_t< T > >

template<typename T >

constexpr bool daw::is_graph_node_v< graph_node_t< T > > = true

inlineconstexpr

Definition at line 341 of file daw_graph.h.

is_integral_v

template<typename T >

constexpr bool daw::is_integral_v = daw::numeric_limits<T>::is_integer

inlineconstexpr

Definition at line 27 of file daw_arith_traits.h.

is_move_insertable_v

template<typename Alloc , typename = void>

constexpr bool daw::is_move_insertable_v

inlineconstexpr

Initial value:

=
    std::is_move_constructible_v<typename Alloc::value_type>

Definition at line 392 of file daw_concepts.h.

is_nonesuch_v

template<typename >

constexpr bool daw::is_nonesuch_v = false

inlineconstexpr

Definition at line 30 of file daw_is_detected.h.

is_nonesuch_v< nonesuch< Op, Args... > >

template<template< class... > class Op, class... Args>

constexpr bool daw::is_nonesuch_v< nonesuch< Op, Args... > > = true

inlineconstexpr

Definition at line 33 of file daw_is_detected.h.

is_nothrow_callable_v

template<size_t N, typename Invokable , typename TpArgs , typename... Args>

constexpr bool daw::is_nothrow_callable_v

inlineconstexpr

Initial value:

= noexcept( std::apply(
    std::declval<Invokable>( ),
    std::tuple_cat( split_args<0, N>( std::forward_as_tuple(
                      DAW_FWD( std::declval<Args>( ) )... ) ),
                    std::declval<TpArgs>( ),
                    split_args<N, sizeof...( Args )>( std::forward_as_tuple(
                      DAW_FWD( std::declval<Args>( ) )... ) ) ) ) )

Definition at line 91 of file daw_bind_args_at.h.

is_nothrow_convertible_v

template<typename From , typename To >

constexpr bool daw::is_nothrow_convertible_v

inlineconstexpr

Initial value:

=
    is_nothrow_convertible<From, To>::value

Definition at line 198 of file cpp_17.h.

is_number_v

template<typename T >

constexpr bool daw::is_number_v

inlineconstexpr

Initial value:

=
    is_integral_v<T> or is_floating_point_v<T>

Definition at line 47 of file daw_arith_traits.h.

is_reference_wrapper_v

template<typename >

constexpr bool daw::is_reference_wrapper_v< std::reference_wrapper< T > > = false

inlineconstexpr

Definition at line 98 of file cpp_17.h.

is_same_size_v

template<typename T , std::size_t BitSize>

constexpr bool daw::is_same_size_v = is_same_size<T, BitSize>::value

inlineconstexpr

Definition at line 199 of file daw_arith_traits.h.

is_same_v

template<typename T , typename U >

constexpr bool daw::is_same_v = false

inlineconstexpr

Definition at line 15 of file daw_traits_is_same.h.

is_same_v< T, T >

template<typename T >

constexpr bool daw::is_same_v< T, T > = true

inlineconstexpr

Definition at line 18 of file daw_traits_is_same.h.

is_signed_v

template<typename T >

constexpr bool daw::is_signed_v

inlineconstexpr

Initial value:

=
    is_number_v<T> and daw::numeric_limits<T>::is_signed

Definition at line 58 of file daw_arith_traits.h.

is_specialization_of_v

template<template< typename... > typename Primary, typename T >

constexpr bool daw::is_specialization_of_v = false

inlineconstexpr

Definition at line 883 of file daw_traits.h.

is_specialization_of_v< Primary, Primary< Args... > >

template<template< typename... > typename Primary, typename... Args>

constexpr bool daw::is_specialization_of_v< Primary, Primary< Args... > >

inlineconstexpr

Initial value:

=
    true

Definition at line 886 of file daw_traits.h.

is_swappable_v

template<typename T >

constexpr bool daw::is_swappable_v = std::is_swappable_v<T>

inlineconstexpr

Definition at line 123 of file cpp_17.h.

is_system_integral_v

template<typename T >

constexpr bool daw::is_system_integral_v = is_system_integral<T>::value

inlineconstexpr

Definition at line 193 of file daw_arith_traits.h.

is_tuple2_v

template<typename >

constexpr bool daw::is_tuple2_v = false

inlineconstexpr

Definition at line 99 of file daw_tuple2.h.

is_tuple2_v< tuple2< Ts... > >

template<typename... Ts>

constexpr bool daw::is_tuple2_v< tuple2< Ts... > > = true

inlineconstexpr

Definition at line 102 of file daw_tuple2.h.

is_tuple_like_v

template<typename Tp , typename = void>

constexpr bool daw::is_tuple_like_v = false

inlineconstexpr

Definition at line 956 of file daw_traits.h.

is_tuple_v

template<typename >

constexpr bool daw::is_tuple_v< std::tuple< Args... > > = false

inlineconstexpr

Definition at line 16 of file daw_tuple_traits.h.

is_unbounded_array_v

template<typename T >

constexpr bool daw::is_unbounded_array_v = false

inlineconstexpr

Definition at line 51 of file cpp_20.h.

is_unbounded_array_v< T[]>

template<typename T >

constexpr bool daw::is_unbounded_array_v< T[]> = true

inlineconstexpr

Definition at line 54 of file cpp_20.h.

is_unsigned_v

template<typename T >

constexpr bool daw::is_unsigned_v

inlineconstexpr

Initial value:

=
    is_integral_v<T> and not daw::numeric_limits<T>::is_signed

Definition at line 69 of file daw_arith_traits.h.

is_visitable_v

template<typename Value , typename... Visitors>

constexpr bool daw::is_visitable_v

inlineconstexpr

Initial value:

=
    ( std::is_invocable_v<Visitors, Value> or ... )

Definition at line 421 of file daw_visit.h.

lift

template<auto fp>

constexpr overload_details::lift_t<fp> daw::lift

inlineconstexpr

Initial value:

=
    overload_details::lift_t<fp>{ }

Definition at line 73 of file daw_overload.h.

lowest_value

template<typename T >

constexpr auto daw::lowest_value = numeric_limits<T>::lowest( )

inlineconstexpr

Definition at line 234 of file daw_arith_traits.h.

mask_from_lsb16

template<unsigned N>

constexpr UInt16 daw::mask_from_lsb16

inlineconstexpr

Initial value:

= [] {
    static_assert( N <= 16 );
    if constexpr( N == 0 ) {
      return UInt16( );
    } else {
      auto const One = ~to_uint16( 1U );
      return ~( One << ( N - 1 ) );
    }
  }( )

Definition at line 2977 of file daw_uint_types.h.

mask_from_lsb32

template<unsigned N>

constexpr UInt32 daw::mask_from_lsb32

inlineconstexpr

Initial value:

= [] {
    static_assert( N <= 32 );
    if constexpr( N == 0 ) {
      return UInt32( );
    } else {
      auto const One = ~to_uint32( 1U );
      return ~( One << ( N - 1 ) );
    }
  }( )

Definition at line 2966 of file daw_uint_types.h.

mask_from_lsb64

template<unsigned N>

constexpr UInt64 daw::mask_from_lsb64

inlineconstexpr

Initial value:

= [] {
    static_assert( N <= 64 );
    if constexpr( N == 0 ) {
      return UInt64( );
    } else {
      auto const One = ~to_uint64( 1U );
      return ~( One << ( N - 1 ) );
    }
  }( )

Definition at line 2955 of file daw_uint_types.h.

mask_from_lsb8

template<unsigned N>

constexpr UInt8 daw::mask_from_lsb8

inlineconstexpr

Initial value:

= [] {
    static_assert( N <= 8 );
    if constexpr( N == 0 ) {
      return UInt8( );
    } else {
      auto const One = ~to_uint8( 1U );
      return ~( One << ( N - 1 ) );
    }
  }( )

Definition at line 2988 of file daw_uint_types.h.

max_digits10

template<typename T >

constexpr auto daw::max_digits10 = numeric_limits<T>::max_digits10

inlineconstexpr

Definition at line 237 of file daw_arith_traits.h.

max_value

template<typename T >

constexpr auto daw::max_value = numeric_limits<T>::max( )

inlineconstexpr

Definition at line 228 of file daw_arith_traits.h.

min_value

template<typename T >

constexpr auto daw::min_value = numeric_limits<T>::min( )

inlineconstexpr

Definition at line 231 of file daw_arith_traits.h.

never_null

constexpr never_null_t daw::never_null = never_null_t{ }

inlineconstexpr

Definition at line 24 of file daw_not_null.h.

nodiscard

constexpr auto daw::nodiscard = nodiscard_t{ }

inlineconstexpr

Definition at line 15 of file daw_view_tags.h.

none_of

template<auto needle, auto... needles>

constexpr none_of_t<decltype( needle ), needle, needles...> daw::none_of { }

inlinestaticconstexpr

Definition at line 80 of file daw_view_tags.h.

not_null_null_value

template<typename T >

constexpr T daw::not_null_null_value = T{ }

inlineconstexpr

Definition at line 27 of file daw_not_null.h.

not_null_null_value< T * >

template<typename T >

constexpr T* daw::not_null_null_value< T * > = nullptr

inlineconstexpr

Definition at line 30 of file daw_not_null.h.

nullopt

constexpr std::nullopt_t daw::nullopt = std::nullopt

inlineconstexpr

Definition at line 20 of file daw_optional.h.

pack_index_of_v

template<typename T , typename... Ts>

constexpr auto daw::pack_index_of_v

inlineconstexpr

Initial value:

= [] {
    auto result = sizeof...( Ts );
    auto pos = std::size_t( -1 );
    
    std::size_t expander[]{
      ( (void)++pos, std::is_same_v<Ts, T> ? ( result = pos ) : pos )... };
    (void)expander;
    return result;
  }( )

Definition at line 627 of file daw_utility.h.

pack_size_v

template<typename Pack >

constexpr auto daw::pack_size_v = deleted<Pack>

inlineconstexpr

Definition at line 32 of file daw_pack_element.h.

pack_size_v< Pack< Ts... > >

template<template< typename... > typename Pack, typename... Ts>

constexpr std::size_t daw::pack_size_v< Pack< Ts... > > = sizeof...( Ts )

inlineconstexpr

Definition at line 35 of file daw_pack_element.h.

param_pack_index_of_v

template<typename T , typename >

constexpr auto daw::param_pack_index_of_v = deleted<T>

inlineconstexpr

Definition at line 642 of file daw_utility.h.

param_pack_index_of_v< Pack< Ts... >, T >

template<template< typename... > typename Pack, typename... Ts, typename T >

constexpr std::size_t daw::param_pack_index_of_v< Pack< Ts... >, T >

inlineconstexpr

Initial value:

=
    pack_index_of_v<T, Ts...>

Definition at line 645 of file daw_utility.h.

reset_on_take

template<typename T >

constexpr bool daw::reset_on_take = true

inlineconstexpr

Definition at line 26 of file daw_take.h.

sized_for_overwrite

constexpr sized_for_overwrite_t daw::sized_for_overwrite

inlineconstexpr

Initial value:

=
    sized_for_overwrite_t{ }

Definition at line 252 of file daw_vector.h.

tag

template<typename... Args>

constexpr tag_t<Args...> daw::tag = tag_t<Args...>{ }

constexpr

Definition at line 656 of file daw_utility.h.

take_ownership

constexpr take_ownership_t daw::take_ownership { }

inlineconstexpr

Definition at line 28 of file daw_fixed_array.h.

template_arg

template<typename T >

constexpr template_param<T> daw::template_arg = template_param<T>{ }

inlineconstexpr

Definition at line 866 of file daw_traits.h.

template_args

template<typename... Ts>

constexpr template_params<Ts...> daw::template_args

inlineconstexpr

Initial value:

=
    template_params<Ts...>{ }

Definition at line 862 of file daw_traits.h.

template_vals

template<auto... vals>

constexpr template_vals_t<vals...> daw::template_vals

inlineconstexpr

Initial value:

=
    template_vals_t<vals...>{ }

Definition at line 872 of file daw_traits.h.

terminate_on_read_file_error

constexpr auto daw::terminate_on_read_file_error

inlineconstexpr

Initial value:

=
    terminate_on_read_file_error_t{ }

Definition at line 59 of file daw_read_file.h.

to_lower_ascii

constexpr auto daw::to_lower_ascii = to_lower_ascii_t{ }

inlineconstexpr

Definition at line 97 of file daw_ascii.h.

to_upper_ascii

constexpr auto daw::to_upper_ascii = to_upper_ascii_t{ }

inlineconstexpr

Definition at line 82 of file daw_ascii.h.

tuple2_size_v

template<typename T >

constexpr std::size_t daw::tuple2_size_v = tuple2_size<T>::value

inlinestaticconstexpr

Definition at line 167 of file daw_tuple2.h.

tuple_size_v

template<typename Tuple >

constexpr size_t daw::tuple_size_v

inlineconstexpr

Initial value:

=
    decltype( tuple::tuple_details::tuple_size_test(
      std::declval<Tuple>( ) ) )::value

Definition at line 500 of file daw_tuple_helper.h.

undefined_v

template<typename T >

constexpr auto daw::undefined_v = impl::undefind_fn_t<T>{ }

inlineconstexpr

Definition at line 35 of file daw_undefined.h.